fix: use new PathLookup methods

BD103 · BD103 · commit f6b06452a70b · 2025-06-25T16:28:00.000-04:00
diff --git a/bevy_lint/src/lints/cargo.rs b/bevy_lint/src/lints/cargo.rs
@@ -5,7 +5,6 @@ use crate::declare_bevy_lint_pass;
 use cargo_metadata::MetadataCommand;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{config::Input, utils::was_invoked_from_cargo};
-use rustc_span::Symbol;
 
 declare_bevy_lint_pass! {
     pub(crate) Cargo => [DUPLICATE_BEVY_DEPENDENCIES],
diff --git a/bevy_lint/src/lints/nursery/duplicate_bevy_dependencies.rs b/bevy_lint/src/lints/nursery/duplicate_bevy_dependencies.rs
@@ -73,7 +73,7 @@ use clippy_utils::{
 };
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_lint::LateContext;
-use rustc_span::{BytePos, Pos, SourceFile, Span, Symbol, SyntaxContext};
+use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
 use serde::Deserialize;
 use toml::Spanned;
 
diff --git a/bevy_lint/src/lints/nursery/zst_query.rs b/bevy_lint/src/lints/nursery/zst_query.rs
@@ -54,10 +54,7 @@ use crate::{
     declare_bevy_lint, declare_bevy_lint_pass,
     utils::hir_parse::{detuple, generic_type_at},
 };
-use clippy_utils::{
-    diagnostics::span_lint_and_help,
-    ty::{match_type, ty_from_hir_ty},
-};
+use clippy_utils::{diagnostics::span_lint_and_help, ty::ty_from_hir_ty};
 use rustc_abi::Size;
 use rustc_hir::AmbigArg;
 use rustc_lint::{LateContext, LateLintPass};
@@ -123,7 +120,7 @@ enum QueryKind {
 
 impl QueryKind {
     fn try_from_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Self> {
-        if match_type(cx, ty, &crate::paths::QUERY) {
+        if crate::paths::QUERY.matches_ty(cx, ty) {
             Some(Self::Query)
         } else {
             None
diff --git a/bevy_lint/src/lints/pedantic/borrowed_reborrowable.rs b/bevy_lint/src/lints/pedantic/borrowed_reborrowable.rs
@@ -101,8 +101,8 @@ use std::ops::ControlFlow;
 use crate::{declare_bevy_lint, declare_bevy_lint_pass};
 use clippy_utils::{
     diagnostics::span_lint_and_sugg,
+    paths::PathLookup,
     source::{snippet, snippet_opt},
-    ty::match_type,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{Body, FnDecl, MutTy, Mutability, intravisit::FnKind};
@@ -255,7 +255,7 @@ impl Reborrowable {
     fn try_from_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Self> {
         use crate::paths::*;
 
-        const PATH_MAP: &[(&[&str], Reborrowable)] = &[
+        static PATH_MAP: &[(&PathLookup, Reborrowable)] = &[
             (&COMMANDS, Reborrowable::Commands),
             (&DEFERRED, Reborrowable::Deferred),
             (&DEFERRED_WORLD, Reborrowable::DeferredWorld),
@@ -271,7 +271,7 @@ impl Reborrowable {
         ];
 
         for &(path, reborrowable) in PATH_MAP {
-            if match_type(cx, ty, path) {
+            if path.matches_ty(cx, ty) {
                 return Some(reborrowable);
             }
         }
diff --git a/bevy_lint/src/lints/pedantic/main_return_without_appexit.rs b/bevy_lint/src/lints/pedantic/main_return_without_appexit.rs
@@ -36,12 +36,12 @@
 use crate::{declare_bevy_lint, declare_bevy_lint_pass, sym, utils::hir_parse::MethodCall};
 use clippy_utils::{
     diagnostics::span_lint_hir_and_then, is_entrypoint_fn, is_expr_used_or_unified,
-    ty::match_type, visitors::for_each_expr,
+    visitors::for_each_expr,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{Body, FnDecl, FnRetTy, Ty, TyKind, def_id::LocalDefId, intravisit::FnKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
 use std::ops::ControlFlow;
 
 declare_bevy_lint! {
@@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for MainReturnWithoutAppExit {
                     let ty = cx.typeck_results().expr_ty(receiver).peel_refs();
 
                     // If `src` is a Bevy `App` and the `AppExit` is unused, emit the lint.
-                    if match_type(cx, ty, &crate::paths::APP)
+                    if crate::paths::APP.matches_ty(cx, ty)
                         && !is_expr_used_or_unified(cx.tcx, expr)
                     {
                         span_lint_hir_and_then(
diff --git a/bevy_lint/src/lints/restriction/missing_reflect.rs b/bevy_lint/src/lints/restriction/missing_reflect.rs
@@ -56,19 +56,15 @@
 
 use crate::{declare_bevy_lint, declare_bevy_lint_pass};
 use clippy_utils::{
-    def_path_res,
     diagnostics::span_lint_hir_and_then,
-    get_trait_def_id,
+    paths::PathLookup,
     sugg::DiagExt,
     ty::{implements_trait, ty_from_hir_ty},
 };
 use rustc_errors::Applicability;
-use rustc_hir::{
-    HirId, Item, ItemKind, Node, OwnerId, QPath, TyKind,
-    def::{DefKind, Res},
-};
+use rustc_hir::{HirId, Item, ItemKind, Node, OwnerId, QPath, TyKind, def::DefKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::{span_bug, ty::TyCtxt};
+use rustc_middle::span_bug;
 use rustc_span::Span;
 
 declare_bevy_lint! {
@@ -87,36 +83,27 @@ impl<'tcx> LateLintPass<'tcx> for MissingReflect {
     fn check_crate(&mut self, cx: &LateContext<'tcx>) {
         // Finds all types that implement `Reflect` in this crate.
         let reflected: Vec<TraitType> =
-            TraitType::from_local_crate(cx.tcx, &crate::paths::REFLECT).collect();
+            TraitType::from_local_crate(cx, &crate::paths::REFLECT).collect();
 
         // Finds all non-`Reflect` types that implement `Event` in this crate.
-        let events: Vec<TraitType> = TraitType::from_local_crate(cx.tcx, &crate::paths::EVENT)
+        let events: Vec<TraitType> = TraitType::from_local_crate(cx, &crate::paths::EVENT)
             .filter(|trait_type| !reflected.contains(trait_type))
             .collect();
 
         // Finds all non-`Reflect` types that implement `Component` and *not* `Event` in this
         // crate. Because events are also components, we need to deduplicate the two to avoid
         // emitting multiple diagnostics for the same type.
-        let components: Vec<TraitType> =
-            TraitType::from_local_crate(cx.tcx, &crate::paths::COMPONENT)
-                .filter(|trait_type| {
-                    !(reflected.contains(trait_type) || events.contains(trait_type))
-                })
-                .collect();
+        let components: Vec<TraitType> = TraitType::from_local_crate(cx, &crate::paths::COMPONENT)
+            .filter(|trait_type| !(reflected.contains(trait_type) || events.contains(trait_type)))
+            .collect();
 
         // Finds all non-`Reflect` types that implement `Resource` in this crate.
-        let resources: Vec<TraitType> =
-            TraitType::from_local_crate(cx.tcx, &crate::paths::RESOURCE)
-                .filter(|trait_type| !reflected.contains(trait_type))
-                .collect();
+        let resources: Vec<TraitType> = TraitType::from_local_crate(cx, &crate::paths::RESOURCE)
+            .filter(|trait_type| !reflected.contains(trait_type))
+            .collect();
+
+        let reflect_trait_def_ids = crate::paths::PARTIAL_REFLECT.get(cx);
 
-        // This is an expensive function that is purposefully called outside of the `for` loop. Note
-        // that this will only return `None` if `PartialReflect` does not exist (e.g. `bevy_reflect`
-        // is not available.)
-        let Some(reflect_trait_def_id) = get_trait_def_id(cx.tcx, &crate::paths::PARTIAL_REFLECT)
-        else {
-            return;
-        };
         // Emit diagnostics for each of these types.
         for (checked_trait, trait_name, message_phrase) in [
             (events, "Event", "an event"),
@@ -173,7 +160,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingReflect {
                     // Check if the field's type implements the `PartialReflect` trait. If it does
                     // not, change the `Applicability` level to `MaybeIncorrect` because `Reflect`
                     // cannot be automatically derived.
-                    if !implements_trait(cx, ty, reflect_trait_def_id, &[]) {
+                    if !reflect_trait_def_ids
+                        .iter()
+                        .any(|&trait_id| implements_trait(cx, ty, trait_id, &[]))
+                    {
                         applicability = Applicability::MaybeIncorrect;
                         break;
                     }
@@ -220,34 +210,32 @@ struct TraitType {
 }
 
 impl TraitType {
-    fn from_local_crate<'tcx>(
-        tcx: TyCtxt<'tcx>,
-        trait_path: &[&str],
-    ) -> impl Iterator<Item = Self> + use<'tcx> {
+    fn from_local_crate<'tcx, 'a>(
+        cx: &'a LateContext<'tcx>,
+        trait_path: &'a PathLookup,
+    ) -> impl Iterator<Item = Self> + use<'tcx, 'a> {
         // Find the `DefId` of the trait. There may be multiple if there are multiple versions of
         // the same crate.
-        let trait_def_ids = def_path_res(tcx, trait_path)
+        let trait_def_ids = trait_path
+            .get(cx)
             .into_iter()
-            .filter_map(|res| match res {
-                Res::Def(DefKind::Trait, def_id) => Some(def_id),
-                _ => None,
-            });
+            .filter(|&def_id| cx.tcx.def_kind(def_id) == DefKind::Trait);
 
         // Find a map of all trait `impl` items within the current crate. The key is the `DefId` of
         // the trait, and the value is a `Vec<LocalDefId>` for all `impl` items.
-        let all_trait_impls = tcx.all_local_trait_impls(());
+        let all_trait_impls = cx.tcx.all_local_trait_impls(());
 
         // Find all `impl` items for the specific trait.
         let trait_impls = trait_def_ids
-            .filter_map(|def_id| all_trait_impls.get(&def_id))
+            .filter_map(|def_id| all_trait_impls.get(def_id))
             .flatten()
             .copied();
 
         // Map the `DefId`s of `impl` items to `TraitType`s. Sometimes this conversion can fail, so
         // we use `filter_map()` to skip errors.
         trait_impls.filter_map(move |local_def_id| {
             // Retrieve the node of the `impl` item from its `DefId`.
-            let node = tcx.hir_node_by_def_id(local_def_id);
+            let node = cx.tcx.hir_node_by_def_id(local_def_id);
 
             // Verify that it's an `impl` item and not something else.
             let Node::Item(Item {
@@ -284,7 +272,7 @@ impl TraitType {
 
             // Find the span where the type was declared. This is guaranteed to be an item, so we
             // can safely call `expect_item()` without it panicking.
-            let item_span = tcx.hir_node(hir_id).expect_item().span;
+            let item_span = cx.tcx.hir_node(hir_id).expect_item().span;
 
             Some(TraitType {
                 hir_id,
diff --git a/bevy_lint/src/lints/restriction/panicking_methods.rs b/bevy_lint/src/lints/restriction/panicking_methods.rs
@@ -55,7 +55,6 @@ use crate::{
 use clippy_utils::{
     diagnostics::span_lint_and_help,
     source::{snippet, snippet_opt},
-    ty::match_type,
 };
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
@@ -215,9 +214,9 @@ enum PanickingType {
 impl PanickingType {
     /// Returns the corresponding variant for the given [`Ty`], if it is supported by this lint.
     fn try_from_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Self> {
-        if match_type(cx, ty, &crate::paths::QUERY) {
+        if crate::paths::QUERY.matches_ty(cx, ty) {
             Some(Self::Query)
-        } else if match_type(cx, ty, &crate::paths::WORLD) {
+        } else if crate::paths::WORLD.matches_ty(cx, ty) {
             Some(Self::World)
         } else {
             None
diff --git a/bevy_lint/src/lints/suspicious/insert_event_resource.rs b/bevy_lint/src/lints/suspicious/insert_event_resource.rs
@@ -40,18 +40,18 @@
 //! ```
 
 use crate::{
-    declare_bevy_lint, declare_bevy_lint_pass, sym, utils::hir_parse::{generic_args_snippet, span_args, MethodCall}
+    declare_bevy_lint, declare_bevy_lint_pass, sym,
+    utils::hir_parse::{MethodCall, generic_args_snippet, span_args},
 };
 use clippy_utils::{
     diagnostics::span_lint_and_sugg,
     source::{snippet, snippet_with_applicability},
-    ty::{match_type, ty_from_hir_ty},
+    ty::ty_from_hir_ty,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, GenericArg, GenericArgs, Path, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Ty, TyKind};
-use rustc_span::Symbol;
 use std::borrow::Cow;
 
 declare_bevy_lint! {
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for InsertEventResource {
                 .peel_refs();
 
             // If `src` is not a Bevy `App`, exit.
-            if !match_type(cx, src_ty, &crate::paths::APP) {
+            if !crate::paths::APP.matches_ty(cx, src_ty) {
                 return;
             }
 
@@ -113,7 +113,7 @@ fn check_insert_resource(cx: &LateContext<'_>, method_call: &MethodCall) {
     let ty = cx.typeck_results().expr_ty(arg);
 
     // If `arg` is `Events<T>`, emit the lint.
-    if match_type(cx, ty, &crate::paths::EVENTS) {
+    if crate::paths::EVENTS.matches_ty(cx, ty) {
         let mut applicability = Applicability::MachineApplicable;
 
         let event_ty_snippet = extract_ty_event_snippet(ty, &mut applicability);
@@ -191,7 +191,7 @@ fn check_init_resource<'tcx>(cx: &LateContext<'tcx>, method_call: &MethodCall<'t
         let resource_ty = ty_from_hir_ty(cx, resource_hir_ty.as_unambig_ty());
 
         // If the resource type is `Events<T>`, emit the lint.
-        if match_type(cx, resource_ty, &crate::paths::EVENTS) {
+        if crate::paths::EVENTS.matches_ty(cx, resource_ty) {
             let mut applicability = Applicability::MachineApplicable;
 
             let event_ty_snippet =
diff --git a/bevy_lint/src/lints/suspicious/insert_unit_bundle.rs b/bevy_lint/src/lints/suspicious/insert_unit_bundle.rs
@@ -50,12 +50,11 @@
 //! # bevy::ecs::system::assert_is_system(spawn);
 //! ```
 
-use clippy_utils::{diagnostics::span_lint_hir_and_then, ty::match_type};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Ty, TyKind};
-use rustc_span::Symbol;
 
 use crate::{declare_bevy_lint, declare_bevy_lint_pass, sym, utils::hir_parse::MethodCall};
 
@@ -88,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for InsertUnitBundle {
         // If the method call was not to `Commands::spawn()` or originates from an external macro,
         // we skip it.
         if !(span.in_external_macro(cx.tcx.sess.source_map())
-            || match_type(cx, src_ty, &crate::paths::COMMANDS)
+            || crate::paths::COMMANDS.matches_ty(cx, src_ty)
                 && method_path.ident.name == sym::spawn)
         {
             return;
diff --git a/bevy_lint/src/lints/suspicious/iter_current_update_events.rs b/bevy_lint/src/lints/suspicious/iter_current_update_events.rs
@@ -38,10 +38,9 @@
 //! }
 //! ```
 
-use clippy_utils::{diagnostics::span_lint_and_help, ty::match_type};
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::Symbol;
 
 use crate::{declare_bevy_lint, declare_bevy_lint_pass, sym, utils::hir_parse::MethodCall};
 
@@ -83,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for IterCurrentUpdateEvents {
                 .expr_ty_adjusted(method_call.receiver)
                 .peel_refs();
 
-            if !match_type(cx, src_ty, &crate::paths::EVENTS) {
+            if !crate::paths::EVENTS.matches_ty(cx, src_ty) {
                 return;
             }
 
diff --git a/bevy_lint/src/paths.rs b/bevy_lint/src/paths.rs
@@ -8,7 +8,7 @@ use clippy_utils::paths::{PathLookup, PathNS};
 use crate::sym;
 
 /// Returns a new [`PathLookup`] in the [type namespace](PathNS::Type) for a given path.
-/// 
+///
 /// `type_path!()` takes a `::`-separated list of identifiers. Each identifier should correspond to
 /// a [`Symbol`](rustc_span::Symbol) in [`crate::sym`]. For example,
 /// `type_path!(bevy_app::app::App)` creates a [`PathLookup`] in the [`PathNS::Type`] namespace
@@ -40,7 +40,8 @@ pub static EVENT: PathLookup = type_path!(bevy_ecs::event::base::Event);
 /// <https://github.com/bevyengine/bevy/blob/v0.16.0/crates/bevy_ecs/src/event/collections.rs#L94>
 pub static EVENTS: PathLookup = type_path!(bevy_ecs::event::collections::Events);
 /// <https://github.com/bevyengine/bevy/blob/v0.16.0/crates/bevy_ecs/src/world/entity_ref.rs#L3687>
-pub static FILTERED_ENTITY_MUT: PathLookup = type_path!(bevy_ecs::world::entity_ref::FilteredEntityMut);
+pub static FILTERED_ENTITY_MUT: PathLookup =
+    type_path!(bevy_ecs::world::entity_ref::FilteredEntityMut);
 /// <https://github.com/bevyengine/bevy/blob/v0.16.0/crates/bevy_ecs/src/change_detection.rs#L1059>
 pub static MUT_UNTYPED: PathLookup = type_path!(bevy_ecs::change_detection::MutUntyped);
 /// <https://github.com/bevyengine/bevy/blob/v0.16.0/crates/bevy_ecs/src/change_detection.rs#L959>
diff --git a/bevy_lint/src/utils/hir_parse.rs b/bevy_lint/src/utils/hir_parse.rs
@@ -1,6 +1,6 @@
 //! Utility functions for parsing HIR types.
 
-use clippy_utils::{match_def_path, source::snippet_opt};
+use clippy_utils::{paths::PathLookup, source::snippet_opt};
 use rustc_hir::{
     Expr, ExprKind, GenericArg, GenericArgs, Impl, Node, Path, PathSegment, QPath, Ty, TyKind,
     def::{DefKind, Res},
@@ -303,10 +303,12 @@ impl<'tcx> MethodCall<'tcx> {
 }
 
 /// Checks if the [`Impl`] implements a given trait from Bevy.
-pub fn impls_trait(cx: &LateContext, impl_: &Impl, trait_path: &[&str]) -> bool {
+pub fn impls_trait(cx: &LateContext, impl_: &Impl, trait_path: &PathLookup) -> bool {
     impl_.of_trait.is_some_and(|of_trait| {
-        matches!(of_trait.path.res, Res::Def(_, trait_def_id)
-            // is the trait being implemented the specified trait from Bevy
-            if match_def_path(cx, trait_def_id, trait_path))
+        matches!(
+            of_trait.path.res,
+            // Is the trait being implemented the specified trait from Bevy?
+            Res::Def(_, trait_def_id) if trait_path.matches(cx, trait_def_id)
+        )
     })
 }
