bevy_lint/lints/suspicious/
insert_event_resource.rs

1//! Checks for the `Events<T>` resource being manually inserted with `App::init_resource()` or
2//! `App::insert_resource()` instead of with `App::add_event()`.
3//!
4//! # Motivation
5//!
6//! Unless you have intentionally and knowingly initialized the `Events<T>` resource in this way,
7//! events and their resources should be initialized with `App::add_event()` because it
8//! automatically handles dropping old events. Just adding `Events<T>` makes no such guarantee, and
9//! will likely result in a memory leak.
10//!
11//! For more information, please see the documentation on [`App::add_event()`] and [`Events<T>`].
12//!
13//! [`Events<T>`]: https://dev-docs.bevyengine.org/bevy/ecs/event/struct.Events.html
14//! [`App::add_event()`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.add_event
15//!
16//! # Example
17//!
18//! ```
19//! # use bevy::prelude::*;
20//! #
21//! #[derive(Event)]
22//! struct MyEvent;
23//!
24//! fn plugin(app: &mut App) {
25//!     app.init_resource::<Events<MyEvent>>();
26//! }
27//! ```
28//!
29//! Use instead:
30//!
31//! ```
32//! # use bevy::prelude::*;
33//! #
34//! #[derive(Event)]
35//! struct MyEvent;
36//!
37//! fn plugin(app: &mut App) {
38//!     app.add_event::<MyEvent>();
39//! }
40//! ```
41
42use crate::{
43    declare_bevy_lint, declare_bevy_lint_pass,
44    utils::hir_parse::{MethodCall, generic_args_snippet, span_args},
45};
46use clippy_utils::{
47    diagnostics::span_lint_and_sugg,
48    source::{snippet, snippet_with_applicability},
49    sym,
50    ty::{match_type, ty_from_hir_ty},
51};
52use rustc_errors::Applicability;
53use rustc_hir::{Expr, GenericArg, GenericArgs, Path, PathSegment, QPath};
54use rustc_lint::{LateContext, LateLintPass};
55use rustc_middle::ty::{Ty, TyKind};
56use rustc_span::Symbol;
57use std::borrow::Cow;
58
59declare_bevy_lint! {
60    pub INSERT_EVENT_RESOURCE,
61    super::SUSPICIOUS,
62    "called `App::insert_resource(Events<T>)` or `App::init_resource::<Events<T>>()` instead of `App::add_event::<T>()`",
63}
64
65declare_bevy_lint_pass! {
66    pub InsertEventResource => [INSERT_EVENT_RESOURCE.lint],
67    @default = {
68        insert_resource: Symbol = sym!(insert_resource),
69        init_resource: Symbol = sym!(init_resource),
70    },
71}
72
73const HELP_MESSAGE: &str = "inserting an `Events` resource does not fully setup that event";
74
75impl<'tcx> LateLintPass<'tcx> for InsertEventResource {
76    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
77        // skip expressions that originate from external macros
78        if expr.span.in_external_macro(cx.tcx.sess.source_map()) {
79            return;
80        }
81
82        // Find a method call.
83        if let Some(method_call) = MethodCall::try_from(cx, expr) {
84            // Get the type for `src` in `src.method()`. We peel all references because the type
85            // could either be `App` or `&mut App`.
86            let src_ty = cx
87                .typeck_results()
88                .expr_ty(method_call.receiver)
89                .peel_refs();
90
91            // If `src` is not a Bevy `App`, exit.
92            if !match_type(cx, src_ty, &crate::paths::APP) {
93                return;
94            }
95
96            // If the method is `App::insert_resource()` or `App::init_resource()`, check it with
97            // its corresponding function.
98            match method_call.method_path.ident.name {
99                symbol if symbol == self.insert_resource => {
100                    check_insert_resource(cx, &method_call);
101                }
102                symbol if symbol == self.init_resource => {
103                    check_init_resource(cx, &method_call);
104                }
105                _ => {}
106            }
107        }
108    }
109}
110
111/// Checks if `App::insert_resource()` inserts an `Events<T>`, and emits a diagnostic if so.
112fn check_insert_resource(cx: &LateContext<'_>, method_call: &MethodCall) {
113    // Extract the argument if there is only 1 (which there should be!), else exit.
114    let [arg] = method_call.args else {
115        return;
116    };
117
118    // Find the type of `arg` in `App::insert_resource(&mut self, arg)`.
119    let ty = cx.typeck_results().expr_ty(arg);
120
121    // If `arg` is `Events<T>`, emit the lint.
122    if match_type(cx, ty, &crate::paths::EVENTS) {
123        let mut applicability = Applicability::MachineApplicable;
124
125        let event_ty_snippet = extract_ty_event_snippet(ty, &mut applicability);
126        let args_snippet = snippet(cx, span_args(method_call.args), "");
127        let generics_snippet = generic_args_snippet(cx, method_call.method_path);
128
129        if method_call.is_fully_qulified {
130            let receiver_snippet = snippet(cx, method_call.receiver.span, "");
131            span_lint_and_sugg(
132                cx,
133                INSERT_EVENT_RESOURCE.lint,
134                method_call.span,
135                format!(
136                    "called `App::insert_resource{generics_snippet}({receiver_snippet}, {args_snippet})` instead of `App::add_event::<{event_ty_snippet}>({receiver_snippet})`"
137                ),
138                HELP_MESSAGE,
139                format!("App::add_event::<{event_ty_snippet}>({receiver_snippet})"),
140                applicability,
141            );
142        } else {
143            span_lint_and_sugg(
144                cx,
145                INSERT_EVENT_RESOURCE.lint,
146                method_call.span,
147                format!(
148                    "called `App::insert_resource{generics_snippet}({args_snippet})` instead of `App::add_event::<{event_ty_snippet}>()`"
149                ),
150                HELP_MESSAGE,
151                format!("add_event::<{event_ty_snippet}>()"),
152                applicability,
153            );
154        }
155    }
156}
157
158/// Creates a string representation of type `T` for [`Ty`] `Events<T>`.
159///
160/// This takes a mutable applicability reference, and will set it to
161/// [`Applicability::HasPlaceholders`] if the type cannot be stringified.
162fn extract_ty_event_snippet<'tcx>(
163    events_ty: Ty<'tcx>,
164    applicability: &mut Applicability,
165) -> Cow<'tcx, str> {
166    const DEFAULT: Cow<str> = Cow::Borrowed("T");
167
168    let TyKind::Adt(_, events_arguments) = events_ty.kind() else {
169        if let Applicability::MachineApplicable = applicability {
170            *applicability = Applicability::HasPlaceholders;
171        }
172
173        return DEFAULT;
174    };
175
176    let Some(event_snippet) = events_arguments.iter().next() else {
177        if let Applicability::MachineApplicable = applicability {
178            *applicability = Applicability::HasPlaceholders;
179        }
180
181        return DEFAULT;
182    };
183
184    format!("{event_snippet:?}").into()
185}
186
187/// Checks if `App::init_resource()` inserts an `Events<T>`, and emits a diagnostic if so.
188fn check_init_resource<'tcx>(cx: &LateContext<'tcx>, method_call: &MethodCall<'tcx>) {
189    if let Some(&GenericArgs {
190        // `App::init_resource()` has one generic type argument: T.
191        args: &[GenericArg::Type(resource_hir_ty)],
192        ..
193    }) = method_call.method_path.args
194    {
195        // Lower `rustc_hir::Ty` to `ty::Ty`, so we can inspect type information. For more
196        // information, see <https://rustc-dev-guide.rust-lang.org/ty.html#rustc_hirty-vs-tyty>.
197        let resource_ty = ty_from_hir_ty(cx, resource_hir_ty.as_unambig_ty());
198
199        // If the resource type is `Events<T>`, emit the lint.
200        if match_type(cx, resource_ty, &crate::paths::EVENTS) {
201            let mut applicability = Applicability::MachineApplicable;
202
203            let event_ty_snippet =
204                extract_hir_event_snippet(cx, resource_hir_ty.as_unambig_ty(), &mut applicability);
205
206            let args_snippet = snippet(cx, span_args(method_call.args), "");
207            let generics_snippet = generic_args_snippet(cx, method_call.method_path);
208
209            if method_call.is_fully_qulified {
210                let receiver_snippet = snippet(cx, method_call.receiver.span, "");
211                span_lint_and_sugg(
212                    cx,
213                    INSERT_EVENT_RESOURCE.lint,
214                    method_call.span,
215                    format!(
216                        "called `App::init_resource{generics_snippet}({receiver_snippet})` instead of `App::add_event::<{event_ty_snippet}>({receiver_snippet})`"
217                    ),
218                    HELP_MESSAGE,
219                    format!("App::add_event::<{event_ty_snippet}>({receiver_snippet})"),
220                    applicability,
221                );
222            } else {
223                span_lint_and_sugg(
224                    cx,
225                    INSERT_EVENT_RESOURCE.lint,
226                    method_call.span,
227                    format!(
228                        "called `App::init_resource{generics_snippet}({args_snippet})` instead of `App::add_event::<{event_ty_snippet}>()`"
229                    ),
230                    HELP_MESSAGE,
231                    format!("add_event::<{event_ty_snippet}>()"),
232                    applicability,
233                );
234            }
235        }
236    }
237}
238
239/// Tries to extract the snippet `MyEvent` from the [`rustc_hir::Ty`] representing
240/// `Events<MyEvent>`.
241///
242/// Note that this works on a best-effort basis, and will return `"T"` if the type cannot be
243/// extracted. If so, it will mutate the passed applicability to [`Applicability::HasPlaceholders`],
244/// similar to [`snippet_with_applicability()`].
245fn extract_hir_event_snippet<'tcx>(
246    cx: &LateContext<'tcx>,
247    events_hir_ty: &rustc_hir::Ty<'tcx>,
248    applicability: &mut Applicability,
249) -> Cow<'static, str> {
250    const DEFAULT: Cow<str> = Cow::Borrowed("T");
251
252    // This is some crazy pattern matching. Let me walk you through it:
253    let event_span = match events_hir_ty.kind {
254        // There are multiple kinds of HIR types, but we're looking for a path to a type
255        // definition. This path is likely `Events`, and contains the generic argument that we're
256        // searching for.
257        rustc_hir::TyKind::Path(QPath::Resolved(
258            _,
259            &Path {
260                // There can be multiple segments in a path, such as if it were
261                // `bevy::prelude::Events`, but in this case we just care about the last: `Events`.
262                segments:
263                    &[
264                        ..,
265                        PathSegment {
266                            // Find the arguments to `Events<T>`, extracting `T`.
267                            args:
268                                Some(&GenericArgs {
269                                    args: &[GenericArg::Type(ty)],
270                                    ..
271                                }),
272                            ..
273                        },
274                    ],
275                ..
276            },
277        )) => {
278            // We now have the HIR type `T` for `Events<T>`, let's return its span.
279            ty.span
280        }
281        // Something in the above pattern matching went wrong, likely due to an edge case. For
282        // this, we set the applicability to `HasPlaceholders` and return the default snippet.
283        _ => {
284            if let Applicability::MachineApplicable = applicability {
285                *applicability = Applicability::HasPlaceholders;
286            }
287
288            return DEFAULT;
289        }
290    };
291
292    // We now have the span to the event type, so let's try to extract it into a string.
293    snippet_with_applicability(cx, event_span, &DEFAULT, applicability)
294}
bevy_lint/lints/suspicious/insert_event_resource.rs

bevy_lint/lints/suspicious/
insert_event_resource.rs
