3ead10a3e0
# Objective The clippy lint `type_complexity` is known not to play well with bevy. It frequently triggers when writing complex queries, and taking the lint's advice of using a type alias almost always just obfuscates the code with no benefit. Because of this, this lint is currently ignored in CI, but unfortunately it still shows up when viewing bevy code in an IDE. As someone who's made a fair amount of pull requests to this repo, I will say that this issue has been a consistent thorn in my side. Since bevy code is filled with spurious, ignorable warnings, it can be very difficult to spot the *real* warnings that must be fixed -- most of the time I just ignore all warnings, only to later find out that one of them was real after I'm done when CI runs. ## Solution Suppress this lint in all bevy crates. This was previously attempted in #7050, but the review process ended up making it more complicated than it needs to be and landed on a subpar solution. The discussion in https://github.com/rust-lang/rust-clippy/pull/10571 explores some better long-term solutions to this problem. Since there is no timeline on when these solutions may land, we should resolve this issue in the meantime by locally suppressing these lints. ### Unresolved issues Currently, these lints are not suppressed in our examples, since that would require suppressing the lint in every single source file. They are still ignored in CI.
96 lines
2.9 KiB
Rust
96 lines
2.9 KiB
Rust
#![allow(clippy::type_complexity)]
|
|
|
|
extern crate proc_macro;
|
|
|
|
mod app_plugin;
|
|
mod bevy_main;
|
|
mod derefs;
|
|
mod enum_variant_meta;
|
|
|
|
use bevy_macro_utils::{derive_label, BevyManifest};
|
|
use proc_macro::TokenStream;
|
|
use quote::format_ident;
|
|
|
|
/// Generates a dynamic plugin entry point function for the given `Plugin` type.
|
|
#[proc_macro_derive(DynamicPlugin)]
|
|
pub fn derive_dynamic_plugin(input: TokenStream) -> TokenStream {
|
|
app_plugin::derive_dynamic_plugin(input)
|
|
}
|
|
|
|
/// Implements [`Deref`] for _single-item_ structs. This is especially useful when
|
|
/// utilizing the [newtype] pattern.
|
|
///
|
|
/// If you need [`DerefMut`] as well, consider using the other [derive] macro alongside
|
|
/// this one.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// use bevy_derive::Deref;
|
|
///
|
|
/// #[derive(Deref)]
|
|
/// struct MyNewtype(String);
|
|
///
|
|
/// let foo = MyNewtype(String::from("Hello"));
|
|
/// assert_eq!(5, foo.len());
|
|
/// ```
|
|
///
|
|
/// [`Deref`]: std::ops::Deref
|
|
/// [newtype]: https://doc.rust-lang.org/rust-by-example/generics/new_types.html
|
|
/// [`DerefMut`]: std::ops::DerefMut
|
|
/// [derive]: crate::derive_deref_mut
|
|
#[proc_macro_derive(Deref)]
|
|
pub fn derive_deref(input: TokenStream) -> TokenStream {
|
|
derefs::derive_deref(input)
|
|
}
|
|
|
|
/// Implements [`DerefMut`] for _single-item_ structs. This is especially useful when
|
|
/// utilizing the [newtype] pattern.
|
|
///
|
|
/// [`DerefMut`] requires a [`Deref`] implementation. You can implement it manually or use
|
|
/// Bevy's [derive] macro for convenience.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// use bevy_derive::{Deref, DerefMut};
|
|
///
|
|
/// #[derive(Deref, DerefMut)]
|
|
/// struct MyNewtype(String);
|
|
///
|
|
/// let mut foo = MyNewtype(String::from("Hello"));
|
|
/// foo.push_str(" World!");
|
|
/// assert_eq!("Hello World!", *foo);
|
|
/// ```
|
|
///
|
|
/// [`DerefMut`]: std::ops::DerefMut
|
|
/// [newtype]: https://doc.rust-lang.org/rust-by-example/generics/new_types.html
|
|
/// [`Deref`]: std::ops::Deref
|
|
/// [derive]: crate::derive_deref
|
|
#[proc_macro_derive(DerefMut)]
|
|
pub fn derive_deref_mut(input: TokenStream) -> TokenStream {
|
|
derefs::derive_deref_mut(input)
|
|
}
|
|
|
|
#[proc_macro_attribute]
|
|
pub fn bevy_main(attr: TokenStream, item: TokenStream) -> TokenStream {
|
|
bevy_main::bevy_main(attr, item)
|
|
}
|
|
|
|
#[proc_macro_derive(EnumVariantMeta)]
|
|
pub fn derive_enum_variant_meta(input: TokenStream) -> TokenStream {
|
|
enum_variant_meta::derive_enum_variant_meta(input)
|
|
}
|
|
|
|
/// Generates an impl of the `AppLabel` trait.
|
|
///
|
|
/// This works only for unit structs, or enums with only unit variants.
|
|
/// You may force a struct or variant to behave as if it were fieldless with `#[app_label(ignore_fields)]`.
|
|
#[proc_macro_derive(AppLabel, attributes(app_label))]
|
|
pub fn derive_app_label(input: TokenStream) -> TokenStream {
|
|
let input = syn::parse_macro_input!(input as syn::DeriveInput);
|
|
let mut trait_path = BevyManifest::default().get_path("bevy_app");
|
|
trait_path.segments.push(format_ident!("AppLabel").into());
|
|
derive_label(input, &trait_path, "app_label")
|
|
}
|