bevy_lint/lints/restriction/
missing_reflect.rs

1//! Checks for components, resources, and events that do not implement `Reflect`.
2//!
3//! # Motivation
4//!
5//! Reflection lets programs inspect type information at runtime. It is commonly used by tools to
6//! view and edit ECS information while the program is running. Reflection is opt-in, however, and
7//! easy to forget since you need to `#[derive(Reflect)]` for each type that uses it.
8//!
9//! # Known issues
10//!
11//! This lint will suggest `#[derive(Reflect)]` even if it cannot be applied. (E.g. if one of the
12//! fields does not implement `Reflect`.) For more information, please see [#141].
13//!
14//! [#141]: https://github.com/TheBevyFlock/bevy_cli/issues/141
15//!
16//! # Example
17//!
18//! ```
19//! # use bevy::prelude::*;
20//! #
21//! #[derive(Component)]
22//! struct MyComponent;
23//! ```
24//!
25//! Use instead:
26//!
27//! ```
28//! # use bevy::prelude::*;
29//! #
30//! // Remember to also register this component in the `App` type registry.
31//! #[derive(Component, Reflect)]
32//! struct MyComponent;
33//! ```
34//!
35//! Often you'll only want to enable this lint for a specific module:
36//!
37//! <!-- We currently ignore this doc test because any reference to `bevy_lint` causes it to be
38//! linked, which raises a compile error due to the linter's use of `rustc_private`. -->
39//!
40//! ```ignore
41//! mod types {
42//!     #![cfg_attr(bevy_lint, warn(bevy::missing_reflect))]
43//! #
44//! #   use bevy::prelude::*;
45//!
46//!     #[derive(Resource, Reflect)]
47//!     struct Score(u32);
48//!
49//!     #[derive(Component, Reflect)]
50//!     struct Happiness(i8);
51//! }
52//! ```
53//!
54//! For more information, please see [Toggling Lints in
55//! Code](../../index.html#toggling-lints-in-code).
56
57use crate::{declare_bevy_lint, declare_bevy_lint_pass};
58use clippy_utils::{def_path_res, diagnostics::span_lint_hir_and_then, sugg::DiagExt};
59use rustc_errors::Applicability;
60use rustc_hir::{
61    HirId, Item, ItemKind, Node, OwnerId, QPath, TyKind,
62    def::{DefKind, Res},
63};
64use rustc_lint::{LateContext, LateLintPass};
65use rustc_middle::ty::TyCtxt;
66use rustc_span::Span;
67
68declare_bevy_lint! {
69    pub MISSING_REFLECT,
70    super::RESTRICTION,
71    "defined a component, resource, or event without a `Reflect` implementation",
72    // We only override `check_crate()`.
73    @crate_level_only = true,
74}
75
76declare_bevy_lint_pass! {
77    pub MissingReflect => [MISSING_REFLECT.lint],
78}
79
80impl<'tcx> LateLintPass<'tcx> for MissingReflect {
81    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
82        // Finds all types that implement `Reflect` in this crate.
83        let reflected: Vec<TraitType> =
84            TraitType::from_local_crate(cx.tcx, &crate::paths::REFLECT).collect();
85
86        // Finds all non-`Reflect` types that implement `Event` in this crate.
87        let events: Vec<TraitType> = TraitType::from_local_crate(cx.tcx, &crate::paths::EVENT)
88            .filter(|trait_type| !reflected.contains(trait_type))
89            .collect();
90
91        // Finds all non-`Reflect` types that implement `Component` and *not* `Event` in this
92        // crate. Because events are also components, we need to deduplicate the two to avoid
93        // emitting multiple diagnostics for the same type.
94        let components: Vec<TraitType> =
95            TraitType::from_local_crate(cx.tcx, &crate::paths::COMPONENT)
96                .filter(|trait_type| {
97                    !(reflected.contains(trait_type) || events.contains(trait_type))
98                })
99                .collect();
100
101        // Finds all non-`Reflect` types that implement `Resource` in this crate.
102        let resources: Vec<TraitType> =
103            TraitType::from_local_crate(cx.tcx, &crate::paths::RESOURCE)
104                .filter(|trait_type| !reflected.contains(trait_type))
105                .collect();
106
107        // Emit diagnostics for each of these types.
108        for (checked_trait, trait_name, message_phrase) in [
109            (events, "Event", "an event"),
110            (components, "Component", "a component"),
111            (resources, "Resource", "a resource"),
112        ] {
113            for without_reflect in checked_trait {
114                // Skip if a types originates from a foreign crate's macro
115                if without_reflect
116                    .item_span
117                    .in_external_macro(cx.tcx.sess.source_map())
118                {
119                    continue;
120                }
121
122                span_lint_hir_and_then(
123                    cx,
124                    MISSING_REFLECT.lint,
125                    // This tells `rustc` where to search for `#[allow(...)]` attributes.
126                    without_reflect.hir_id,
127                    without_reflect.item_span,
128                    format!("defined {message_phrase} without a `Reflect` implementation"),
129                    |diag| {
130                        diag.span_note(
131                            without_reflect.impl_span,
132                            format!("`{trait_name}` implemented here"),
133                        )
134                        .suggest_item_with_attr(
135                            cx,
136                            without_reflect.item_span,
137                            "`Reflect` can be automatically derived",
138                            "#[derive(Reflect)]",
139                            // This can usually be automatically applied by `rustfix` without
140                            // issues, unless one of the fields of the struct does not
141                            // implement `Reflect` (see #141).
142                            // This suggestion may result in two consecutive
143                            // `#[derive(...)]` attributes, but `rustfmt` merges them
144                            // afterwards.
145                            Applicability::MaybeIncorrect,
146                        );
147                    },
148                );
149            }
150        }
151    }
152}
153
154/// Represents a type that implements a specific trait.
155#[derive(Debug)]
156struct TraitType {
157    /// The [`HirId`] pointing to the type item declaration.
158    hir_id: HirId,
159    /// The span where the type was declared.
160    item_span: Span,
161    /// The span where the trait was implemented.
162    impl_span: Span,
163}
164
165impl TraitType {
166    fn from_local_crate<'tcx>(
167        tcx: TyCtxt<'tcx>,
168        trait_path: &[&str],
169    ) -> impl Iterator<Item = Self> + use<'tcx> {
170        // Find the `DefId` of the trait. There may be multiple if there are multiple versions of
171        // the same crate.
172        let trait_def_ids = def_path_res(tcx, trait_path)
173            .into_iter()
174            .filter_map(|res| match res {
175                Res::Def(DefKind::Trait, def_id) => Some(def_id),
176                _ => None,
177            });
178
179        // Find a map of all trait `impl` items within the current crate. The key is the `DefId` of
180        // the trait, and the value is a `Vec<LocalDefId>` for all `impl` items.
181        let all_trait_impls = tcx.all_local_trait_impls(());
182
183        // Find all `impl` items for the specific trait.
184        let trait_impls = trait_def_ids
185            .filter_map(|def_id| all_trait_impls.get(&def_id))
186            .flatten()
187            .copied();
188
189        // Map the `DefId`s of `impl` items to `TraitType`s. Sometimes this conversion can fail, so
190        // we use `filter_map()` to skip errors.
191        trait_impls.filter_map(move |local_def_id| {
192            // Retrieve the node of the `impl` item from its `DefId`.
193            let node = tcx.hir_node_by_def_id(local_def_id);
194
195            // Verify that it's an `impl` item and not something else.
196            let Node::Item(Item {
197                kind: ItemKind::Impl(impl_),
198                span: impl_span,
199                ..
200            }) = node
201            else {
202                return None;
203            };
204
205            // Find where `T` in `impl T` was originally defined, after peeling away all references
206            // `&`. This was adapted from `clippy_utils::path_res()` in order to avoid passing
207            // `LateContext` to this function.
208            let def_id = match impl_.self_ty.peel_refs().kind {
209                TyKind::Path(QPath::Resolved(_, path)) => path.res.opt_def_id()?,
210                _ => return None,
211            };
212
213            // Tries to convert the `DefId` to a `LocalDefId`, exiting early if it cannot be done.
214            // This will only work if `T` in `impl T` is defined within the same crate.
215            //
216            // In most cases this will succeed due to Rust's orphan rule, but it notably fails
217            // within `bevy_reflect` itself, since that crate implements `Reflect` for `std` types
218            // such as `String`.
219            let local_def_id = def_id.as_local()?;
220
221            // Find the `HirId` from the `LocalDefId`. This is like a `DefId`, but with further
222            // constraints on what it can represent.
223            let hir_id = OwnerId {
224                def_id: local_def_id,
225            }
226            .into();
227
228            // Find the span where the type was declared. This is guaranteed to be an item, so we
229            // can safely call `expect_item()` without it panicking.
230            let item_span = tcx.hir_node(hir_id).expect_item().span;
231
232            Some(TraitType {
233                hir_id,
234                item_span,
235                impl_span: *impl_span,
236            })
237        })
238    }
239}
240
241/// A custom equality implementation that just checks the [`HirId`] of the [`TraitType`], and skips
242/// the other values.
243///
244/// [`TraitType`]s with equal [`HirId`]s are guaranteed to be equal in all other fields, so this
245/// takes advantage of that fact.
246impl PartialEq for TraitType {
247    fn eq(&self, other: &Self) -> bool {
248        self.hir_id == other.hir_id
249    }
250}
bevy_lint/lints/restriction/missing_reflect.rs

bevy_lint/lints/restriction/
missing_reflect.rs
