user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Retire hir::*ItemRef.

Browse source
This commit is contained in:
Camille GILLOT 2025-07-02 20:15:28 +00:00
parent 5bd3841668
commit 21fd82adbc
52 changed files with 244 additions and 308 deletions
Download patch file Download diff file Expand all files Collapse all files

16
compiler/rustc_ast_lowering/src/index.rs
View file

@ -381,20 +381,12 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
})
}
fn visit_trait_item_ref(&mut self, ii: &'hir TraitItemRef) {
// Do not visit the duplicate information in TraitItemRef. We want to
// map the actual nodes, not the duplicate ones in the *Ref.
let TraitItemRef { id, ident: _, span: _ } = *ii;
self.visit_nested_trait_item(id);
fn visit_trait_item_ref(&mut self, id: &'hir TraitItemId) {
self.visit_nested_trait_item(*id);
}
fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef) {
// Do not visit the duplicate information in ImplItemRef. We want to
// map the actual nodes, not the duplicate ones in the *Ref.
let ImplItemRef { id, ident: _, span: _ } = *ii;
self.visit_nested_impl_item(id);
fn visit_impl_item_ref(&mut self, id: &'hir ImplItemId) {
self.visit_nested_impl_item(*id);
}
fn visit_foreign_item_ref(&mut self, id: &'hir ForeignItemId) {

19
compiler/rustc_ast_lowering/src/item.rs
View file

@ -964,13 +964,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
self.arena.alloc(item)
}
fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemRef {
let id = hir::TraitItemId { owner_id: self.owner_id(i.id) };
hir::TraitItemRef {
id,
ident: self.lower_ident(i.kind.ident().unwrap()),
span: self.lower_span(i.span),
}
fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemId {
hir::TraitItemId { owner_id: self.owner_id(i.id) }
}
/// Construct `ExprKind::Err` for the given `span`.
@ -1110,14 +1105,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
self.arena.alloc(item)
}
fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
hir::ImplItemRef {
id: hir::ImplItemId { owner_id: self.owner_id(i.id) },
// `unwrap` is safe because `AssocItemKind::{MacCall,DelegationMac}` are the only
// assoc item kinds without an identifier and they cannot reach here.
ident: self.lower_ident(i.kind.ident().unwrap()),
span: self.lower_span(i.span),
}
fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemId {
hir::ImplItemId { owner_id: self.owner_id(i.id) }
}
fn lower_defaultness(

32
compiler/rustc_hir/src/hir.rs
View file

@ -4162,7 +4162,7 @@ impl<'hir> Item<'hir> {
Ident,
&'hir Generics<'hir>,
GenericBounds<'hir>,
&'hir [TraitItemRef]
&'hir [TraitItemId]
),
ItemKind::Trait(is_auto, safety, ident, generics, bounds, items),
(*is_auto, *safety, *ident, generics, bounds, items);
@ -4335,7 +4335,7 @@ pub enum ItemKind<'hir> {
/// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
Union(Ident, &'hir Generics<'hir>, VariantData<'hir>),
/// A trait definition.
Trait(IsAuto, Safety, Ident, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
Trait(IsAuto, Safety, Ident, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemId]),
/// A trait alias.
TraitAlias(Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
@ -4362,7 +4362,7 @@ pub struct Impl<'hir> {
pub of_trait: Option<TraitRef<'hir>>,
pub self_ty: &'hir Ty<'hir>,
pub items: &'hir [ImplItemRef],
pub items: &'hir [ImplItemId],
}
impl ItemKind<'_> {
@ -4405,32 +4405,6 @@ impl ItemKind<'_> {
}
}
/// A reference from an trait to one of its associated items. This
/// contains the item's id, naturally, but also the item's name and
/// some other high-level details (like whether it is an associated
/// type or method, and whether it is public). This allows other
/// passes to find the impl they want without loading the ID (which
/// means fewer edges in the incremental compilation graph).
#[derive(Debug, Clone, Copy, HashStable_Generic)]
pub struct TraitItemRef {
pub id: TraitItemId,
pub ident: Ident,
pub span: Span,
}
/// A reference from an impl to one of its associated items. This
/// contains the item's ID, naturally, but also the item's name and
/// some other high-level details (like whether it is an associated
/// type or method, and whether it is public). This allows other
/// passes to find the impl they want without loading the ID (which
/// means fewer edges in the incremental compilation graph).
#[derive(Debug, Clone, Copy, HashStable_Generic)]
pub struct ImplItemRef {
pub id: ImplItemId,
pub ident: Ident,
pub span: Span,
}
// The bodies for items are stored "out of line", in a separate
// hashmap in the `Crate`. Here we just record the hir-id of the item
// so it can fetched later.

26
compiler/rustc_hir/src/intravisit.rs
View file

@ -435,8 +435,8 @@ pub trait Visitor<'v>: Sized {
fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>) -> Self::Result {
walk_trait_item(self, ti)
}
fn visit_trait_item_ref(&mut self, ii: &'v TraitItemRef) -> Self::Result {
walk_trait_item_ref(self, ii)
fn visit_trait_item_ref(&mut self, ii: &'v TraitItemId) -> Self::Result {
walk_trait_item_ref(self, *ii)
}
fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>) -> Self::Result {
walk_impl_item(self, ii)
@ -444,8 +444,8 @@ pub trait Visitor<'v>: Sized {
fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemId) -> Self::Result {
walk_foreign_item_ref(self, *ii)
}
fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) -> Self::Result {
walk_impl_item_ref(self, ii)
fn visit_impl_item_ref(&mut self, ii: &'v ImplItemId) -> Self::Result {
walk_impl_item_ref(self, *ii)
}
fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>) -> Self::Result {
walk_trait_ref(self, t)
@ -1245,13 +1245,8 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(
V::Result::output()
}
pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(
visitor: &mut V,
trait_item_ref: &'v TraitItemRef,
) -> V::Result {
let TraitItemRef { id, ident, span: _ } = *trait_item_ref;
try_visit!(visitor.visit_nested_trait_item(id));
visitor.visit_ident(ident)
pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: TraitItemId) -> V::Result {
visitor.visit_nested_trait_item(id)
}
pub fn walk_impl_item<'v, V: Visitor<'v>>(
@ -1294,13 +1289,8 @@ pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: ForeignIte
visitor.visit_nested_foreign_item(id)
}
pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(
visitor: &mut V,
impl_item_ref: &'v ImplItemRef,
) -> V::Result {
let ImplItemRef { id, ident, span: _ } = *impl_item_ref;
try_visit!(visitor.visit_nested_impl_item(id));
visitor.visit_ident(ident)
pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: ImplItemId) -> V::Result {
visitor.visit_nested_impl_item(id)
}
pub fn walk_trait_ref<'v, V: Visitor<'v>>(

21
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -844,11 +844,9 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
let item = tcx.hir_expect_item(def_id);
let (is_alias, is_auto, safety, items) = match item.kind {
hir::ItemKind::Trait(is_auto, safety, .., items) => {
(false, is_auto == hir::IsAuto::Yes, safety, items)
}
hir::ItemKind::TraitAlias(..) => (true, false, hir::Safety::Safe, &[][..]),
let (is_alias, is_auto, safety) = match item.kind {
hir::ItemKind::Trait(is_auto, safety, ..) => (false, is_auto == hir::IsAuto::Yes, safety),
hir::ItemKind::TraitAlias(..) => (true, false, hir::Safety::Safe),
_ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
};
@ -911,13 +909,16 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
// functions in the trait with default implementations
.and_then(|(list, attr_span)| {
let errors = list.iter().filter_map(|ident| {
let item = items.iter().find(|item| item.ident == *ident);
let item = tcx
.associated_items(def_id)
.filter_by_name_unhygienic(ident.name)
.find(|item| item.ident(tcx) == *ident);
match item {
Some(item) if matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) => {
if !tcx.defaultness(item.id.owner_id).has_value() {
Some(item) if matches!(item.kind, ty::AssocKind::Fn { .. }) => {
if !item.defaultness(tcx).has_value() {
tcx.dcx().emit_err(errors::FunctionNotHaveDefaultImplementation {
span: item.span,
span: tcx.def_span(item.def_id),
note_span: attr_span,
});
@ -928,7 +929,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
}
Some(item) => {
tcx.dcx().emit_err(errors::MustImplementNotFunction {
span: item.span,
span: tcx.def_span(item.def_id),
span_note: errors::MustImplementNotFunctionSpanNote { span: attr_span },
note: errors::MustImplementNotFunctionNote {},
});

8
compiler/rustc_hir_pretty/src/lib.rs
View file

@ -730,8 +730,8 @@ impl<'a> State<'a> {
self.space();
self.bopen(ib);
for impl_item in items {
self.ann.nested(self, Nested::ImplItem(impl_item.id));
for &impl_item in items {
self.ann.nested(self, Nested::ImplItem(impl_item));
}
self.bclose(item.span, cb);
}
@ -746,8 +746,8 @@ impl<'a> State<'a> {
self.print_where_clause(generics);
self.word(" ");
self.bopen(ib);
for trait_item in trait_items {
self.ann.nested(self, Nested::TraitItem(trait_item.id));
for &trait_item in trait_items {
self.ann.nested(self, Nested::TraitItem(trait_item));
}
self.bclose(item.span, cb);
}

16
compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
View file

@ -1,7 +1,7 @@
use rustc_hir::{self as hir, LangItem};
use rustc_middle::ty;
use rustc_session::{declare_lint, declare_lint_pass};
use rustc_span::sym;
use rustc_span::{Ident, sym};
use rustc_trait_selection::traits::supertraits;
use crate::lints::{SupertraitAsDerefTarget, SupertraitAsDerefTargetLabel};
@ -79,11 +79,15 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
// erase regions in self type for better diagnostic presentation
let (self_ty, target_principal, supertrait_principal) =
tcx.erase_regions((self_ty, target_principal, supertrait_principal));
let label2 = impl_
.items
.iter()
.find_map(|i| (i.ident.name == sym::Target).then_some(i.span))
.map(|label| SupertraitAsDerefTargetLabel { label });
let label2 = tcx
.associated_items(item.owner_id)
.find_by_ident_and_kind(
tcx,
Ident::with_dummy_span(sym::Target),
ty::AssocTag::Type,
item.owner_id.to_def_id(),
)
.map(|label| SupertraitAsDerefTargetLabel { label: tcx.def_span(label.def_id) });
let span = tcx.def_span(item.owner_id.def_id);
cx.emit_span_lint(
DEREF_INTO_DYN_SUPERTRAIT,

2
compiler/rustc_passes/src/check_attr.rs
View file

@ -1152,7 +1152,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
ItemKind::Trait(_, _, _, generics, _, items)
if generics.params.len() != 0
|| items.iter().any(|item| {
matches!(self.tcx.def_kind(item.id.owner_id), DefKind::AssocTy)
matches!(self.tcx.def_kind(item.owner_id), DefKind::AssocTy)
}) => {}
ItemKind::TyAlias(_, generics, _) if generics.params.len() != 0 => {}
_ => {

4
compiler/rustc_passes/src/dead.rs
View file

@ -415,8 +415,8 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
hir::ItemKind::Trait(.., trait_item_refs) => {
// mark assoc ty live if the trait is live
for trait_item in trait_item_refs {
if matches!(self.tcx.def_kind(trait_item.id.owner_id), DefKind::AssocTy) {
self.check_def_id(trait_item.id.owner_id.to_def_id());
if matches!(self.tcx.def_kind(trait_item.owner_id), DefKind::AssocTy) {
self.check_def_id(trait_item.owner_id.to_def_id());
}
}
intravisit::walk_item(self, item)

12
compiler/rustc_passes/src/input_stats.rs
View file

@ -467,9 +467,9 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
hir_visit::walk_trait_item(self, ti)
}
fn visit_trait_item_ref(&mut self, ti: &'v hir::TraitItemRef) {
self.record("TraitItemRef", Some(ti.id.hir_id()), ti);
hir_visit::walk_trait_item_ref(self, ti)
fn visit_trait_item_ref(&mut self, ti: &'v hir::TraitItemId) {
self.record("TraitItemId", Some(ti.hir_id()), ti);
hir_visit::walk_trait_item_ref(self, *ti)
}
fn visit_impl_item(&mut self, ii: &'v hir::ImplItem<'v>) {
@ -485,9 +485,9 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
hir_visit::walk_foreign_item_ref(self, *fi)
}
fn visit_impl_item_ref(&mut self, ii: &'v hir::ImplItemRef) {
self.record("ImplItemRef", Some(ii.id.hir_id()), ii);
hir_visit::walk_impl_item_ref(self, ii)
fn visit_impl_item_ref(&mut self, ii: &'v hir::ImplItemId) {
self.record("ImplItemId", Some(ii.hir_id()), ii);
hir_visit::walk_impl_item_ref(self, *ii)
}
fn visit_param_bound(&mut self, b: &'v hir::GenericBound<'v>) {

9
compiler/rustc_passes/src/stability.rs
View file

@ -880,11 +880,16 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
}
for impl_item_ref in *items {
let impl_item = self.tcx.associated_item(impl_item_ref.id.owner_id);
let impl_item = self.tcx.associated_item(impl_item_ref.owner_id);
if let Some(def_id) = impl_item.trait_item_def_id {
// Pass `None` to skip deprecation warnings.
self.tcx.check_stability(def_id, None, impl_item_ref.span, None);
self.tcx.check_stability(
def_id,
None,
self.tcx.def_span(impl_item_ref.owner_id),
None,
);
}
}
}

10
compiler/rustc_privacy/src/lib.rs
View file

@ -672,14 +672,14 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
self.reach(item.owner_id.def_id, item_ev).generics().predicates();
for trait_item_ref in trait_item_refs {
self.update(trait_item_ref.id.owner_id.def_id, item_ev, Level::Reachable);
self.update(trait_item_ref.owner_id.def_id, item_ev, Level::Reachable);
let tcx = self.tcx;
let mut reach = self.reach(trait_item_ref.id.owner_id.def_id, item_ev);
let mut reach = self.reach(trait_item_ref.owner_id.def_id, item_ev);
reach.generics().predicates();
if let DefKind::AssocTy = tcx.def_kind(trait_item_ref.id.owner_id)
&& !tcx.defaultness(trait_item_ref.id.owner_id).has_value()
if let DefKind::AssocTy = tcx.def_kind(trait_item_ref.owner_id)
&& !tcx.defaultness(trait_item_ref.owner_id).has_value()
{
// No type to visit.
} else {
@ -715,7 +715,7 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
self.reach(item.owner_id.def_id, item_ev).generics().predicates().ty().trait_ref();
for impl_item_ref in impl_.items {
let def_id = impl_item_ref.id.owner_id.def_id;
let def_id = impl_item_ref.owner_id.def_id;
let max_vis =
impl_.of_trait.is_none().then(|| self.tcx.local_visibility(def_id));
self.update_eff_vis(def_id, item_ev, max_vis, Level::Direct);

16
compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
View file

@ -362,7 +362,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
&& self.tcx.trait_of_item(*item_id) == Some(*trait_id)
&& let None = self.tainted_by_errors()
{
let (verb, noun) = match self.tcx.associated_item(item_id).kind {
let assoc_item = self.tcx.associated_item(item_id);
let (verb, noun) = match assoc_item.kind {
ty::AssocKind::Const { .. } => ("refer to the", "constant"),
ty::AssocKind::Fn { .. } => ("call", "function"),
// This is already covered by E0223, but this following single match
@ -381,17 +382,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
);
err.code(E0790);
if let Some(local_def_id) = data.trait_ref.def_id.as_local()
&& let hir::Node::Item(hir::Item {
kind: hir::ItemKind::Trait(_, _, trait_ident, _, _, trait_item_refs),
..
}) = self.tcx.hir_node_by_def_id(local_def_id)
&& let Some(method_ref) = trait_item_refs
.iter()
.find(|item_ref| item_ref.ident == *assoc_item_ident)
{
if item_id.is_local() {
let trait_ident = self.tcx.item_name(*trait_id);
err.span_label(
method_ref.span,
self.tcx.def_span(*item_id),
format!("`{trait_ident}::{assoc_item_ident}` defined here"),
);
}

4
compiler/rustc_trait_selection/src/traits/wf.rs
View file

@ -288,9 +288,9 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
&& let Some(&impl_item_id) =
tcx.impl_item_implementor_ids(impl_def_id).get(&projection_ty.def_id)
&& let Some(impl_item) =
items.iter().find(|item| item.id.owner_id.to_def_id() == impl_item_id)
items.iter().find(|item| item.owner_id.to_def_id() == impl_item_id)
{
Some(tcx.hir_impl_item(impl_item.id).expect_type().span)
Some(tcx.hir_impl_item(*impl_item).expect_type().span)
} else {
None
}

14
compiler/rustc_ty_utils/src/assoc.rs
View file

@ -29,7 +29,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
// query.
let rpitit_items = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
tcx.arena.alloc_from_iter(trait_item_refs.iter().flat_map(|trait_item_ref| {
let item_def_id = trait_item_ref.id.owner_id.to_def_id();
let item_def_id = trait_item_ref.owner_id.to_def_id();
[item_def_id]
.into_iter()
.chain(rpitit_items.get(&item_def_id).into_iter().flatten().copied())
@ -41,7 +41,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
// associated_types_for_impl_traits_in_trait_or_impl query.
let rpitit_items = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
tcx.arena.alloc_from_iter(impl_.items.iter().flat_map(|impl_item_ref| {
let item_def_id = impl_item_ref.id.owner_id.to_def_id();
let item_def_id = impl_item_ref.owner_id.to_def_id();
[item_def_id]
.into_iter()
.chain(rpitit_items.get(&item_def_id).into_iter().flatten().copied())
@ -154,10 +154,10 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
ItemKind::Trait(.., trait_item_refs) => trait_item_refs
.iter()
.filter_map(move |item| {
if !matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) {
if !matches!(tcx.def_kind(item.owner_id), DefKind::AssocFn) {
return None;
}
let fn_def_id = item.id.owner_id.def_id;
let fn_def_id = item.owner_id.def_id;
let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
return Some((fn_def_id.to_def_id(), vec![]));
};
@ -185,11 +185,11 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
.items
.iter()
.filter_map(|item| {
if !matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) {
if !matches!(tcx.def_kind(item.owner_id), DefKind::AssocFn) {
return None;
}
let did = item.id.owner_id.def_id.to_def_id();
let item = tcx.hir_impl_item(item.id);
let did = item.owner_id.def_id.to_def_id();
let item = tcx.hir_impl_item(*item);
let Some(trait_item_def_id) = item.trait_item_def_id else {
return Some((did, vec![]));
};

2
src/librustdoc/clean/inline.rs
View file

@ -499,7 +499,7 @@ pub(crate) fn build_impl(
impl_
.items
.iter()
.map(|item| tcx.hir_impl_item(item.id))
.map(|&item| tcx.hir_impl_item(item))
.filter(|item| {
// Filter out impl items whose corresponding trait item has `doc(hidden)`
// not to document such impl items.

4
src/librustdoc/clean/mod.rs
View file

@ -2867,7 +2867,7 @@ fn clean_maybe_renamed_item<'tcx>(
ItemKind::Trait(_, _, _, generics, bounds, item_ids) => {
let items = item_ids
.iter()
.map(|ti| clean_trait_item(cx.tcx.hir_trait_item(ti.id), cx))
.map(|&ti| clean_trait_item(cx.tcx.hir_trait_item(ti), cx))
.collect();
TraitItem(Box::new(Trait {
@ -2910,7 +2910,7 @@ fn clean_impl<'tcx>(
let items = impl_
.items
.iter()
.map(|ii| clean_impl_item(tcx.hir_impl_item(ii.id), cx))
.map(|&ii| clean_impl_item(tcx.hir_impl_item(ii), cx))
.collect::<Vec<_>>();
// If this impl block is an implementation of the Deref trait, then we

67
src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
View file

@ -8,12 +8,13 @@ use clippy_utils::diagnostics::span_lint_and_note;
use clippy_utils::is_cfg_test;
use rustc_attr_data_structures::AttributeKind;
use rustc_hir::{
Attribute, FieldDef, HirId, ImplItemRef, IsAuto, Item, ItemKind, Mod, OwnerId, QPath, TraitItemRef, TyKind,
Attribute, FieldDef, HirId, IsAuto, ImplItemId, Item, ItemKind, Mod, OwnerId, QPath, TraitItemId, TyKind,
Variant, VariantData,
};
use rustc_middle::ty::AssocKind;
use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_session::impl_lint_pass;
use rustc_span::Ident;
declare_clippy_lint! {
/// ### What it does
@ -195,22 +196,22 @@ impl ArbitrarySourceItemOrdering {
}
/// Produces a linting warning for incorrectly ordered impl items.
fn lint_impl_item<T: LintContext>(&self, cx: &T, item: &ImplItemRef, before_item: &ImplItemRef) {
fn lint_impl_item(&self, cx: &LateContext<'_>, item: ImplItemId, before_item: ImplItemId) {
span_lint_and_note(
cx,
ARBITRARY_SOURCE_ITEM_ORDERING,
item.span,
cx.tcx.def_span(item.owner_id),
format!(
"incorrect ordering of impl items (defined order: {:?})",
self.assoc_types_order
),
Some(before_item.span),
format!("should be placed before `{}`", before_item.ident.name),
Some(cx.tcx.def_span(before_item.owner_id)),
format!("should be placed before `{}`", cx.tcx.item_name(before_item.owner_id)),
);
}
/// Produces a linting warning for incorrectly ordered item members.
fn lint_member_name<T: LintContext>(cx: &T, ident: &rustc_span::Ident, before_ident: &rustc_span::Ident) {
fn lint_member_name<T: LintContext>(cx: &T, ident: Ident, before_ident: Ident) {
span_lint_and_note(
cx,
ARBITRARY_SOURCE_ITEM_ORDERING,
@ -221,7 +222,7 @@ impl ArbitrarySourceItemOrdering {
);
}
fn lint_member_item<T: LintContext>(cx: &T, item: &Item<'_>, before_item: &Item<'_>, msg: &'static str) {
fn lint_member_item(cx: &LateContext<'_>, item: &Item<'_>, before_item: &Item<'_>, msg: &'static str) {
let span = if let Some(ident) = item.kind.ident() {
ident.span
} else {
@ -246,17 +247,17 @@ impl ArbitrarySourceItemOrdering {
}
/// Produces a linting warning for incorrectly ordered trait items.
fn lint_trait_item<T: LintContext>(&self, cx: &T, item: &TraitItemRef, before_item: &TraitItemRef) {
fn lint_trait_item(&self, cx: &LateContext<'_>, item: TraitItemId, before_item: TraitItemId) {
span_lint_and_note(
cx,
ARBITRARY_SOURCE_ITEM_ORDERING,
item.span,
cx.tcx.def_span(item.owner_id),
format!(
"incorrect ordering of trait items (defined order: {:?})",
self.assoc_types_order
),
Some(before_item.span),
format!("should be placed before `{}`", before_item.ident.name),
Some(cx.tcx.def_span(before_item.owner_id)),
format!("should be placed before `{}`", cx.tcx.item_name(before_item.owner_id)),
);
}
}
@ -284,7 +285,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
&& cur_v.ident.name.as_str() > variant.ident.name.as_str()
&& cur_v.span != variant.span
{
Self::lint_member_name(cx, &variant.ident, &cur_v.ident);
Self::lint_member_name(cx, variant.ident, cur_v.ident);
}
cur_v = Some(variant);
}
@ -300,7 +301,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
&& cur_f.ident.name.as_str() > field.ident.name.as_str()
&& cur_f.span != field.span
{
Self::lint_member_name(cx, &field.ident, &cur_f.ident);
Self::lint_member_name(cx, field.ident, cur_f.ident);
}
cur_f = Some(field);
}
@ -308,49 +309,53 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
ItemKind::Trait(is_auto, _safety, _ident, _generics, _generic_bounds, item_ref)
if self.enable_ordering_for_trait && *is_auto == IsAuto::No =>
{
let mut cur_t: Option<&TraitItemRef> = None;
let mut cur_t: Option<(TraitItemId, Ident)> = None;
for item in *item_ref {
if item.span.in_external_macro(cx.sess().source_map()) {
for &item in *item_ref {
let span = cx.tcx.def_span(item.owner_id);
let ident = cx.tcx.item_ident(item.owner_id);
if span.in_external_macro(cx.sess().source_map()) {
continue;
}
if let Some(cur_t) = cur_t {
let cur_t_kind = convert_assoc_item_kind(cx, cur_t.id.owner_id);
if let Some((cur_t, cur_ident)) = cur_t {
let cur_t_kind = convert_assoc_item_kind(cx, cur_t.owner_id);
let cur_t_kind_index = self.assoc_types_order.index_of(&cur_t_kind);
let item_kind = convert_assoc_item_kind(cx,item.id.owner_id);
let item_kind = convert_assoc_item_kind(cx, item.owner_id);
let item_kind_index = self.assoc_types_order.index_of(&item_kind);
if cur_t_kind == item_kind && cur_t.ident.name.as_str() > item.ident.name.as_str() {
Self::lint_member_name(cx, &item.ident, &cur_t.ident);
if cur_t_kind == item_kind && cur_ident.name.as_str() > ident.name.as_str() {
Self::lint_member_name(cx, ident, cur_ident);
} else if cur_t_kind_index > item_kind_index {
self.lint_trait_item(cx, item, cur_t);
}
}
cur_t = Some(item);
cur_t = Some((item, ident));
}
},
ItemKind::Impl(trait_impl) if self.enable_ordering_for_impl => {
let mut cur_t: Option<&ImplItemRef> = None;
let mut cur_t: Option<(ImplItemId, Ident)> = None;
for item in trait_impl.items {
if item.span.in_external_macro(cx.sess().source_map()) {
for &item in trait_impl.items {
let span = cx.tcx.def_span(item.owner_id);
let ident = cx.tcx.item_ident(item.owner_id);
if span.in_external_macro(cx.sess().source_map()) {
continue;
}
if let Some(cur_t) = cur_t {
let cur_t_kind = convert_assoc_item_kind(cx, cur_t.id.owner_id);
if let Some((cur_t, cur_ident)) = cur_t {
let cur_t_kind = convert_assoc_item_kind(cx, cur_t.owner_id);
let cur_t_kind_index = self.assoc_types_order.index_of(&cur_t_kind);
let item_kind = convert_assoc_item_kind(cx, item.id.owner_id);
let item_kind = convert_assoc_item_kind(cx, item.owner_id);
let item_kind_index = self.assoc_types_order.index_of(&item_kind);
if cur_t_kind == item_kind && cur_t.ident.name.as_str() > item.ident.name.as_str() {
Self::lint_member_name(cx, &item.ident, &cur_t.ident);
if cur_t_kind == item_kind && cur_ident.name.as_str() > ident.name.as_str() {
Self::lint_member_name(cx, ident, cur_ident);
} else if cur_t_kind_index > item_kind_index {
self.lint_impl_item(cx, item, cur_t);
}
}
cur_t = Some(item);
cur_t = Some((item, ident));
}
},
_ => {}, // Catch-all for `ItemKinds` that don't have fields.

2
src/tools/clippy/clippy_lints/src/derivable_impls.rs
View file

@ -192,7 +192,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
&& !item.span.from_expansion()
&& let Some(def_id) = trait_ref.trait_def_id()
&& cx.tcx.is_diagnostic_item(sym::Default, def_id)
&& let impl_item_hir = child.id.hir_id()
&& let impl_item_hir = child.hir_id()
&& let Node::ImplItem(impl_item) = cx.tcx.hir_node(impl_item_hir)
&& let ImplItemKind::Fn(_, b) = &impl_item.kind
&& let Body { value: func_expr, .. } = cx.tcx.hir_body(*b)

2
src/tools/clippy/clippy_lints/src/empty_drop.rs
View file

@ -41,7 +41,7 @@ impl LateLintPass<'_> for EmptyDrop {
..
}) = item.kind
&& trait_ref.trait_def_id() == cx.tcx.lang_items().drop_trait()
&& let impl_item_hir = child.id.hir_id()
&& let impl_item_hir = child.hir_id()
&& let Node::ImplItem(impl_item) = cx.tcx.hir_node(impl_item_hir)
&& let ImplItemKind::Fn(_, b) = &impl_item.kind
&& let Body { value: func_expr, .. } = cx.tcx.hir_body(*b)

64
src/tools/clippy/clippy_lints/src/fallible_impl_from.rs
View file

@ -52,20 +52,20 @@ declare_lint_pass!(FallibleImplFrom => [FALLIBLE_IMPL_FROM]);
impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
// check for `impl From<???> for ..`
if let hir::ItemKind::Impl(impl_) = &item.kind
if let hir::ItemKind::Impl(_) = &item.kind
&& let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
&& cx
.tcx
.is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id)
{
lint_impl_body(cx, item.span, impl_.items);
lint_impl_body(cx, item.owner_id, item.span);
}
}
}
fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::ImplItemRef]) {
fn lint_impl_body(cx: &LateContext<'_>, item_def_id: hir::OwnerId, impl_span: Span) {
use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::{Expr, ImplItemKind};
use rustc_hir::Expr;
struct FindPanicUnwrap<'a, 'tcx> {
lcx: &'a LateContext<'tcx>,
@ -96,35 +96,35 @@ fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::Impl
}
}
for impl_item in impl_items {
if impl_item.ident.name == sym::from
&& let ImplItemKind::Fn(_, body_id) = cx.tcx.hir_impl_item(impl_item.id).kind
{
// check the body for `begin_panic` or `unwrap`
let body = cx.tcx.hir_body(body_id);
let mut fpu = FindPanicUnwrap {
lcx: cx,
typeck_results: cx.tcx.typeck(impl_item.id.owner_id.def_id),
result: Vec::new(),
};
fpu.visit_expr(body.value);
for impl_item in cx.tcx.associated_items(item_def_id)
.filter_by_name_unhygienic_and_kind(sym::from, ty::AssocTag::Fn)
{
let impl_item_def_id= impl_item.def_id.expect_local();
// if we've found one, lint
if !fpu.result.is_empty() {
span_lint_and_then(
cx,
FALLIBLE_IMPL_FROM,
impl_span,
"consider implementing `TryFrom` instead",
move |diag| {
diag.help(
"`From` is intended for infallible conversions only. \
Use `TryFrom` if there's a possibility for the conversion to fail",
);
diag.span_note(fpu.result, "potential failure(s)");
},
);
}
// check the body for `begin_panic` or `unwrap`
let body = cx.tcx.hir_body_owned_by(impl_item_def_id);
let mut fpu = FindPanicUnwrap {
lcx: cx,
typeck_results: cx.tcx.typeck(impl_item_def_id),
result: Vec::new(),
};
fpu.visit_expr(body.value);
// if we've found one, lint
if !fpu.result.is_empty() {
span_lint_and_then(
cx,
FALLIBLE_IMPL_FROM,
impl_span,
"consider implementing `TryFrom` instead",
move |diag| {
diag.help(
"`From` is intended for infallible conversions only. \
Use `TryFrom` if there's a possibility for the conversion to fail",
);
diag.span_note(fpu.result, "potential failure(s)");
},
);
}
}
}

8
src/tools/clippy/clippy_lints/src/from_over_into.rs
View file

@ -9,7 +9,7 @@ use clippy_utils::source::SpanRangeExt;
use rustc_errors::Applicability;
use rustc_hir::intravisit::{Visitor, walk_path};
use rustc_hir::{
FnRetTy, GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemRef, Item, ItemKind, PatKind, Path,
FnRetTy, GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemId, Item, ItemKind, PatKind, Path,
PathSegment, Ty, TyKind,
};
use rustc_lint::{LateContext, LateLintPass};
@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
middle_trait_ref.self_ty()
);
if let Some(suggestions) =
convert_to_from(cx, into_trait_seg, target_ty.as_unambig_ty(), self_ty, impl_item_ref)
convert_to_from(cx, into_trait_seg, target_ty.as_unambig_ty(), self_ty, *impl_item_ref)
{
diag.multipart_suggestion(message, suggestions, Applicability::MachineApplicable);
} else {
@ -164,14 +164,14 @@ fn convert_to_from(
into_trait_seg: &PathSegment<'_>,
target_ty: &Ty<'_>,
self_ty: &Ty<'_>,
impl_item_ref: &ImplItemRef,
impl_item_ref: ImplItemId,
) -> Option<Vec<(Span, String)>> {
if !target_ty.find_self_aliases().is_empty() {
// It's tricky to expand self-aliases correctly, we'll ignore it to not cause a
// bad suggestion/fix.
return None;
}
let impl_item = cx.tcx.hir_impl_item(impl_item_ref.id);
let impl_item = cx.tcx.hir_impl_item(impl_item_ref);
let ImplItemKind::Fn(ref sig, body_id) = impl_item.kind else {
return None;
};

2
src/tools/clippy/clippy_lints/src/implicit_hasher.rs
View file

@ -130,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
});
let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
for item in impl_.items.iter().map(|item| cx.tcx.hir_impl_item(item.id)) {
for item in impl_.items.iter().map(|&item| cx.tcx.hir_impl_item(item)) {
ctr_vis.visit_impl_item(item);
}

13
src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
View file

@ -139,13 +139,12 @@ impl LateLintPass<'_> for IterWithoutIntoIter {
// We can't check inherent impls for slices, but we know that they have an `iter(_mut)` method
ty.peel_refs().is_slice() || get_adt_inherent_method(cx, ty, expected_method_name).is_some()
})
&& let Some(iter_assoc_span) = imp.items.iter().find_map(|item| {
if item.ident.name == sym::IntoIter {
Some(cx.tcx.hir_impl_item(item.id).expect_type().span)
} else {
None
}
})
&& let Some(iter_assoc_span) = cx.tcx.associated_items(item.owner_id)
.filter_by_name_unhygienic_and_kind(sym::IntoIter, ty::AssocTag::Type)
.next()
.map(|assoc_item| {
cx.tcx.hir_node_by_def_id(assoc_item.def_id.expect_local()).expect_impl_item().expect_type().span
})
&& is_ty_exported(cx, ty)
{
span_lint_and_then(

10
src/tools/clippy/clippy_lints/src/len_zero.rs
View file

@ -12,7 +12,7 @@ use rustc_hir::def_id::{DefId, DefIdSet};
use rustc_hir::{
BinOpKind, Expr, ExprKind, FnRetTy, GenericArg, GenericBound, HirId, ImplItem, ImplItemKind,
ImplicitSelfKind, Item, ItemKind, Mutability, Node, OpaqueTyOrigin, PatExprKind, PatKind, PathSegment, PrimTy,
QPath, TraitItemRef, TyKind,
QPath, TraitItemId, TyKind,
};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::{self, FnSig, Ty};
@ -265,11 +265,11 @@ fn span_without_enclosing_paren(cx: &LateContext<'_>, span: Span) -> Span {
}
}
fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, ident: Ident, trait_items: &[TraitItemRef]) {
fn is_named_self(cx: &LateContext<'_>, item: &TraitItemRef, name: Symbol) -> bool {
item.ident.name == name
fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, ident: Ident, trait_items: &[TraitItemId]) {
fn is_named_self(cx: &LateContext<'_>, item: &TraitItemId, name: Symbol) -> bool {
cx.tcx.item_name(item.owner_id) == name
&& matches!(
cx.tcx.fn_arg_idents(item.id.owner_id),
cx.tcx.fn_arg_idents(item.owner_id),
[Some(Ident { name: kw::SelfLower, .. })],
)
}

2
src/tools/clippy/clippy_lints/src/lifetimes.rs
View file

@ -716,7 +716,7 @@ fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'
walk_trait_ref(&mut checker, trait_ref);
}
walk_unambig_ty(&mut checker, impl_.self_ty);
for item in impl_.items {
for &item in impl_.items {
walk_impl_item_ref(&mut checker, item);
}

11
src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs
View file

@ -8,7 +8,7 @@ use rustc_ast::LitKind;
use rustc_data_structures::fx::FxHashSet;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::{
Block, Expr, ExprKind, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Node, QPath, TyKind, VariantData,
Block, Expr, ExprKind, Impl, Item, ItemKind, LangItem, Node, QPath, TyKind, VariantData,
};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::{Ty, TypeckResults};
@ -200,7 +200,7 @@ fn check_struct<'tcx>(
impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
// is this an `impl Debug for X` block?
if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, items, .. }) = item.kind
if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, .. }) = item.kind
&& let Res::Def(DefKind::Trait, trait_def_id) = trait_ref.path.res
&& let TyKind::Path(QPath::Resolved(_, self_path)) = &self_ty.kind
// make sure that the self type is either a struct, an enum or a union
@ -212,9 +212,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
&& !cx.tcx.is_automatically_derived(item.owner_id.to_def_id())
&& !item.span.from_expansion()
// find `Debug::fmt` function
&& let Some(fmt_item) = items.iter().find(|i| i.ident.name == sym::fmt)
&& let ImplItem { kind: ImplItemKind::Fn(_, body_id), .. } = cx.tcx.hir_impl_item(fmt_item.id)
&& let body = cx.tcx.hir_body(*body_id)
&& let Some(fmt_item) = cx.tcx.associated_items(item.owner_id).filter_by_name_unhygienic(sym::fmt).next()
&& let body = cx.tcx.hir_body_owned_by(fmt_item.def_id.expect_local())
&& let ExprKind::Block(block, _) = body.value.kind
// inspect `self`
&& let self_ty = cx.tcx.type_of(self_path_did).skip_binder().peel_refs()
@ -222,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
&& let Some(self_def_id) = self_adt.did().as_local()
&& let Node::Item(self_item) = cx.tcx.hir_node_by_def_id(self_def_id)
// NB: can't call cx.typeck_results() as we are not in a body
&& let typeck_results = cx.tcx.typeck_body(*body_id)
&& let typeck_results = cx.tcx.typeck_body(body.id())
&& should_lint(cx, typeck_results, block)
// we intentionally only lint structs, see lint description
&& let ItemKind::Struct(_, _, data) = &self_item.kind

8
src/tools/clippy/clippy_lints/src/missing_inline.rs
View file

@ -104,16 +104,16 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
hir::ItemKind::Trait(ref _is_auto, ref _unsafe, _ident, _generics, _bounds, trait_items) => {
// note: we need to check if the trait is exported so we can't use
// `LateLintPass::check_trait_item` here.
for tit in trait_items {
let tit_ = cx.tcx.hir_trait_item(tit.id);
for &tit in trait_items {
let tit_ = cx.tcx.hir_trait_item(tit);
match tit_.kind {
hir::TraitItemKind::Const(..) | hir::TraitItemKind::Type(..) => {},
hir::TraitItemKind::Fn(..) => {
if cx.tcx.defaultness(tit.id.owner_id).has_value() {
if cx.tcx.defaultness(tit.owner_id).has_value() {
// trait method with default body needs inline in case
// an impl is not provided
let desc = "a default trait method";
let item = cx.tcx.hir_trait_item(tit.id);
let item = cx.tcx.hir_trait_item(tit);
let attrs = cx.tcx.hir_attrs(item.hir_id());
check_missing_inline_attrs(cx, attrs, item.span, desc);
}

6
src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
View file

@ -43,12 +43,12 @@ impl<'tcx> LateLintPass<'tcx> for PartialEqNeImpl {
&& trait_ref.path.res.def_id() == eq_trait
{
for impl_item in *impl_items {
if impl_item.ident.name == sym::ne {
if cx.tcx.item_name(impl_item.owner_id) == sym::ne {
span_lint_hir(
cx,
PARTIALEQ_NE_IMPL,
impl_item.id.hir_id(),
impl_item.span,
impl_item.hir_id(),
cx.tcx.def_span(impl_item.owner_id),
"re-implementing `PartialEq::ne` is unnecessary",
);
}

6
src/tools/clippy/clippy_lints/src/serde_api.rs
View file

@ -36,9 +36,9 @@ impl<'tcx> LateLintPass<'tcx> for SerdeApi {
let mut seen_str = None;
let mut seen_string = None;
for item in *items {
match item.ident.name {
sym::visit_str => seen_str = Some(item.span),
sym::visit_string => seen_string = Some(item.span),
match cx.tcx.item_name(item.owner_id) {
sym::visit_str => seen_str = Some(cx.tcx.def_span(item.owner_id)),
sym::visit_string => seen_string = Some(cx.tcx.def_span(item.owner_id)),
_ => {},
}
}

28
src/tools/clippy/clippy_utils/src/paths.rs
View file

@ -10,7 +10,7 @@ use rustc_data_structures::fx::FxHashMap;
use rustc_hir::def::Namespace::{MacroNS, TypeNS, ValueNS};
use rustc_hir::def::{DefKind, Namespace, Res};
use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
use rustc_hir::{ImplItemRef, ItemKind, Node, OwnerId, TraitItemRef, UseKind};
use rustc_hir::{ItemKind, Node, UseKind};
use rustc_lint::LateContext;
use rustc_middle::ty::fast_reject::SimplifiedType;
use rustc_middle::ty::{FloatTy, IntTy, Ty, TyCtxt, UintTy};
@ -284,14 +284,6 @@ fn local_item_child_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, ns: PathNS, n
_ => return None,
};
let res = |ident: Ident, owner_id: OwnerId| {
if ident.name == name && ns.matches(tcx.def_kind(owner_id).ns()) {
Some(owner_id.to_def_id())
} else {
None
}
};
match item_kind {
ItemKind::Mod(_, r#mod) => r#mod.item_ids.iter().find_map(|&item_id| {
let item = tcx.hir_item(item_id);
@ -307,17 +299,19 @@ fn local_item_child_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, ns: PathNS, n
} else {
None
}
} else if let Some(ident) = item.kind.ident()
&& ident.name == name
&& ns.matches(tcx.def_kind(item.owner_id).ns())
{
Some(item.owner_id.to_def_id())
} else {
res(item.kind.ident()?, item_id.owner_id)
None
}
}),
ItemKind::Impl(r#impl) => r#impl
.items
.iter()
.find_map(|&ImplItemRef { ident, id, .. }| res(ident, id.owner_id)),
ItemKind::Trait(.., trait_item_refs) => trait_item_refs
.iter()
.find_map(|&TraitItemRef { ident, id, .. }| res(ident, id.owner_id)),
ItemKind::Impl(..) | ItemKind::Trait(..)
=> tcx.associated_items(local_id).filter_by_name_unhygienic(name)
.find(|assoc_item| ns.matches(Some(assoc_item.namespace())))
.map(|assoc_item| assoc_item.def_id),
_ => None,
}
}

8
src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
View file

@ -136,13 +136,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:155:5
|
LL | const A: bool;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:153:5
|
LL | type SomeType;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of items (must be alphabetically ordered)
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
@ -172,13 +172,13 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:189:5
|
LL | const A: bool = false;
| ^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:5
|
LL | type SomeType = ();
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: aborting due to 15 previous errors

8
src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default_exp.stderr
View file

@ -136,13 +136,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:155:5
|
LL | const A: bool;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:153:5
|
LL | type SomeType;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of items (must be alphabetically ordered)
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
@ -172,13 +172,13 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:189:5
|
LL | const A: bool = false;
| ^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:5
|
LL | type SomeType = ();
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: aborting due to 15 previous errors

8
src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.ord_within.stderr
View file

@ -211,13 +211,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:155:5
|
LL | const A: bool;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:153:5
|
LL | type SomeType;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of items (must be alphabetically ordered)
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
@ -247,13 +247,13 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:189:5
|
LL | const A: bool = false;
| ^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:5
|
LL | type SomeType = ();
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of items (must be alphabetically ordered)
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:207:11

14
src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
View file

@ -28,25 +28,25 @@ error: incorrect ordering of impl items (defined order: [Fn, Type, Const])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
|
LL | type SomeType = ();
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `A`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:117:5
|
LL | const A: bool = false;
| ^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of impl items (defined order: [Fn, Type, Const])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:122:5
|
LL | fn a() {}
| ^^^^^^^^^
| ^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
|
LL | type SomeType = ();
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of items (must be alphabetically ordered)
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:149:8
@ -76,13 +76,13 @@ error: incorrect ordering of trait items (defined order: [Fn, Type, Const])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:163:5
|
LL | type SomeType;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `A`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:161:5
|
LL | const A: bool;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: incorrect ordering of trait items (defined order: [Fn, Type, Const])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:166:5
@ -94,7 +94,7 @@ note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:163:5
|
LL | type SomeType;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: aborting due to 8 previous errors

8
src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
View file

@ -16,25 +16,25 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:46:5
|
LL | type SomeType = i8;
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `a`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:43:5
|
LL | fn a() {}
| ^^^^^^^^^
| ^^^^^^
error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:49:5
|
LL | const A: bool = true;
| ^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:46:5
|
LL | type SomeType = i8;
| ^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: aborting due to 3 previous errors

4
src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
View file

@ -28,13 +28,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:45:5
|
LL | const A: bool;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
|
note: should be placed before `SomeType`
--> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:43:5
|
LL | type SomeType;
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^
error: aborting due to 3 previous errors

8
src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
View file

@ -1,12 +1,8 @@
error: re-implementing `PartialEq::ne` is unnecessary
--> tests/ui/partialeq_ne_impl.rs:9:5
|
LL | / fn ne(&self, _: &Foo) -> bool {
LL | |
LL | |
LL | | false
LL | | }
| |_____^
LL | fn ne(&self, _: &Foo) -> bool {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::partialeq-ne-impl` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::partialeq_ne_impl)]`

5
src/tools/clippy/tests/ui/serde.stderr
View file

@ -5,10 +5,7 @@ LL | / fn visit_string<E>(self, _v: String) -> Result<Self::Value, E>
LL | |
LL | | where
LL | | E: serde::de::Error,
LL | | {
LL | | unimplemented!()
LL | | }
| |_____^
| |____________________________^
|
= note: `-D clippy::serde-api-misuse` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::serde_api_misuse)]`

2
tests/ui/associated-consts/issue-58022.stderr
View file

@ -16,7 +16,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
--> $DIR/issue-58022.rs:4:25
|
LL | const SIZE: usize;
| ------------------ `Foo::SIZE` defined here
| ----------------- `Foo::SIZE` defined here
LL |
LL | fn new(slice: &[u8; Foo::SIZE]) -> Self;
| ^^^^^^^^^ cannot refer to the associated constant of trait

4
tests/ui/associated-consts/issue-63496.stderr
View file

@ -2,7 +2,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
--> $DIR/issue-63496.rs:4:21
|
LL | const C: usize;
| --------------- `A::C` defined here
| -------------- `A::C` defined here
LL |
LL | fn f() -> ([u8; A::C], [u8; A::C]);
| ^^^^ cannot refer to the associated constant of trait
@ -11,7 +11,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
--> $DIR/issue-63496.rs:4:33
|
LL | const C: usize;
| --------------- `A::C` defined here
| -------------- `A::C` defined here
LL |
LL | fn f() -> ([u8; A::C], [u8; A::C]);
| ^^^^ cannot refer to the associated constant of trait

2
tests/ui/associated-item/issue-48027.stderr
View file

@ -18,7 +18,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
--> $DIR/issue-48027.rs:3:32
|
LL | const X: usize;
| --------------- `Bar::X` defined here
| -------------- `Bar::X` defined here
LL | fn return_n(&self) -> [u8; Bar::X];
| ^^^^^^ cannot refer to the associated constant of trait

11
tests/ui/consts/issue-54954.stderr
View file

@ -10,14 +10,11 @@ LL | const fn const_val<T: Sized>() -> usize {
error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type
--> $DIR/issue-54954.rs:1:24
|
LL | const ARR_LEN: usize = Tt::const_val::<[i8; 123]>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
LL | const ARR_LEN: usize = Tt::const_val::<[i8; 123]>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
...
LL | / const fn const_val<T: Sized>() -> usize {
LL | |
LL | | core::mem::size_of::<T>()
LL | | }
| |_____- `Tt::const_val` defined here
LL | const fn const_val<T: Sized>() -> usize {
| --------------------------------------- `Tt::const_val` defined here
error: aborting due to 2 previous errors

4
tests/ui/error-codes/E0790.stderr
View file

@ -16,7 +16,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
--> $DIR/E0790.rs:21:17
|
LL | const MY_ASSOC_CONST: ();
| ------------------------- `MyTrait::MY_ASSOC_CONST` defined here
| ------------------------ `MyTrait::MY_ASSOC_CONST` defined here
...
LL | let _ = MyTrait::MY_ASSOC_CONST;
| ^^^^^^^^^^^^^^^^^^^^^^^ cannot refer to the associated constant of trait
@ -44,7 +44,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
--> $DIR/E0790.rs:30:13
|
LL | const MY_ASSOC_CONST: ();
| ------------------------- `MyTrait::MY_ASSOC_CONST` defined here
| ------------------------ `MyTrait::MY_ASSOC_CONST` defined here
...
LL | let _ = inner::MyTrait::MY_ASSOC_CONST;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot refer to the associated constant of trait

2
tests/ui/feature-gates/feature-gate-async-drop.stderr
View file

@ -12,7 +12,7 @@ error[E0658]: use of unstable library feature `async_drop`
--> $DIR/feature-gate-async-drop.rs:13:5
|
LL | async fn drop(self: Pin<&mut Self>) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #126482 <https://github.com/rust-lang/rust/issues/126482> for more information
= help: add `#![feature(async_drop)]` to the crate attributes to enable

2
tests/ui/lint/lint-stability.stderr
View file

@ -290,7 +290,7 @@ error[E0658]: use of unstable library feature `unstable_test_feature`
--> $DIR/lint-stability.rs:179:9
|
LL | fn trait_unstable(&self) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: add `#![feature(unstable_test_feature)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

6
tests/ui/stats/input-stats.stderr
View file

@ -112,12 +112,12 @@ hir-stats Param 64 (NN.N%) 2 32
hir-stats GenericArg 64 (NN.N%) 4 16
hir-stats - Type 16 (NN.N%) 1
hir-stats - Lifetime 48 (NN.N%) 3
hir-stats TraitItemRef 48 (NN.N%) 2 24
hir-stats ImplItemRef 48 (NN.N%) 2 24
hir-stats ExprField 40 (NN.N%) 1 40
hir-stats Mod 32 (NN.N%) 1 32
hir-stats Lifetime 28 (NN.N%) 1 28
hir-stats TraitItemId 8 (NN.N%) 2 4
hir-stats ImplItemId 8 (NN.N%) 2 4
hir-stats ForeignItemId 4 (NN.N%) 1 4
hir-stats ----------------------------------------------------------------
hir-stats Total 8_664 173
hir-stats Total 8_584 173
hir-stats ================================================================

2
tests/ui/suggestions/issue-104327.stderr
View file

@ -2,7 +2,7 @@ error[E0790]: cannot call associated function on trait without specifying the co
--> $DIR/issue-104327.rs:10:5
|
LL | fn f() {}
| --------- `Foo::f` defined here
| ------ `Foo::f` defined here
...
LL | Foo::f();
| ^^^^^^^^ cannot call associated function of trait

4
tests/ui/traits/default-method/rustc_must_implement_one_of_misuse.stderr
View file

@ -50,7 +50,7 @@ error: not a function
--> $DIR/rustc_must_implement_one_of_misuse.rs:26:5
|
LL | const A: u8 = 1;
| ^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^
|
note: required by this annotation
--> $DIR/rustc_must_implement_one_of_misuse.rs:24:1
@ -63,7 +63,7 @@ error: not a function
--> $DIR/rustc_must_implement_one_of_misuse.rs:28:5
|
LL | type B;
| ^^^^^^^
| ^^^^^^
|
note: required by this annotation
--> $DIR/rustc_must_implement_one_of_misuse.rs:24:1

2
tests/ui/traits/trait-upcasting/deref-upcast-shadowing-lint.stderr
View file

@ -5,7 +5,7 @@ LL | impl<'a> Deref for dyn Foo + 'a {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo` implements `Deref<Target = dyn Bar<u32>>` which conflicts with supertrait `Bar<i32>`
LL |
LL | type Target = dyn Bar<u32> + 'a;
| -------------------------------- target type is a supertrait of `dyn Foo`
| ----------- target type is a supertrait of `dyn Foo`
|
note: the lint level is defined here
--> $DIR/deref-upcast-shadowing-lint.rs:2:9

2
tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.stderr
View file

@ -5,7 +5,7 @@ LL | impl<'a> Deref for dyn Foo<'a> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo<'_>` implements `Deref<Target = dyn Bar<'_>>` which conflicts with supertrait `Bar<'_>`
LL |
LL | type Target = dyn Bar<'a>;
| -------------------------- target type is a supertrait of `dyn Foo<'_>`
| ----------- target type is a supertrait of `dyn Foo<'_>`
|
note: the lint level is defined here
--> $DIR/migrate-lint-deny-regions.rs:2:9

2
tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr
View file

@ -5,7 +5,7 @@ LL | impl<'a> Deref for dyn Foo + 'a {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo` implements `Deref<Target = dyn Bar<u32>>` which conflicts with supertrait `Bar<i32>`
LL |
LL | type Target = dyn Bar<u32> + 'a;
| -------------------------------- target type is a supertrait of `dyn Foo`
| ----------- target type is a supertrait of `dyn Foo`
|
note: the lint level is defined here
--> $DIR/migrate-lint-different-substs.rs:2:9