Vendor dependencies for 0.3.0 release

vendor/bevy_derive/src/bevy_main.rs

@@ -0,0 +1,26 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, ItemFn};
+
+pub fn bevy_main(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+    assert_eq!(
+        input.sig.ident, "main",
+        "`bevy_main` can only be used on a function called 'main'."
+    );
+
+    TokenStream::from(quote! {
+        // SAFETY: `#[bevy_main]` should only be placed on a single `main` function
+        // TODO: Potentially make `bevy_main` and unsafe attribute as there is a safety
+        // guarantee required from the caller.
+        #[unsafe(no_mangle)]
+        #[cfg(target_os = "android")]
+        fn android_main(android_app: bevy::window::android_activity::AndroidApp) {
+            let _ = bevy::window::ANDROID_APP.set(android_app);
+            main();
+        }
+
+        #[allow(unused)]
+        #input
+    })
+}

vendor/bevy_derive/src/derefs.rs

@@ -0,0 +1,113 @@
+use proc_macro::{Span, TokenStream};
+use quote::quote;
+use syn::{parse_macro_input, Data, DeriveInput, Field, Index, Member, Type};
+
+const DEREF: &str = "Deref";
+const DEREF_MUT: &str = "DerefMut";
+const DEREF_ATTR: &str = "deref";
+
+pub fn derive_deref(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let ident = &ast.ident;
+    let (field_member, field_type) = match get_deref_field(&ast, false) {
+        Ok(items) => items,
+        Err(err) => {
+            return err.into_compile_error().into();
+        }
+    };
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics ::core::ops::Deref for #ident #ty_generics #where_clause {
+            type Target = #field_type;
+
+            fn deref(&self) -> &Self::Target {
+                &self.#field_member
+            }
+        }
+    })
+}
+
+pub fn derive_deref_mut(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let ident = &ast.ident;
+    let (field_member, _) = match get_deref_field(&ast, true) {
+        Ok(items) => items,
+        Err(err) => {
+            return err.into_compile_error().into();
+        }
+    };
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics ::core::ops::DerefMut for #ident #ty_generics #where_clause {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.#field_member
+            }
+        }
+    })
+}
+
+fn get_deref_field(ast: &DeriveInput, is_mut: bool) -> syn::Result<(Member, &Type)> {
+    let deref_kind = if is_mut { DEREF_MUT } else { DEREF };
+    let deref_attr_str = format!("`#[{DEREF_ATTR}]`");
+
+    match &ast.data {
+        Data::Struct(data_struct) if data_struct.fields.is_empty() => Err(syn::Error::new(
+            Span::call_site().into(),
+            format!("{deref_kind} cannot be derived on field-less structs"),
+        )),
+        Data::Struct(data_struct) if data_struct.fields.len() == 1 => {
+            let field = data_struct.fields.iter().next().unwrap();
+            let member = to_member(field, 0);
+            Ok((member, &field.ty))
+        }
+        Data::Struct(data_struct) => {
+            let mut selected_field: Option<(Member, &Type)> = None;
+            for (index, field) in data_struct.fields.iter().enumerate() {
+                for attr in &field.attrs {
+                    if !attr.meta.path().is_ident(DEREF_ATTR) {
+                        continue;
+                    }
+
+                    attr.meta.require_path_only()?;
+
+                    if selected_field.is_some() {
+                        return Err(syn::Error::new_spanned(
+                            attr,
+                            format!(
+                                "{deref_attr_str} attribute can only be used on a single field"
+                            ),
+                        ));
+                    }
+
+                    let member = to_member(field, index);
+                    selected_field = Some((member, &field.ty));
+                }
+            }
+
+            if let Some(selected_field) = selected_field {
+                Ok(selected_field)
+            } else {
+                Err(syn::Error::new(
+                    Span::call_site().into(),
+                    format!("deriving {deref_kind} on multi-field structs requires one field to have the {deref_attr_str} attribute"),
+                ))
+            }
+        }
+        _ => Err(syn::Error::new(
+            Span::call_site().into(),
+            format!("{deref_kind} can only be derived on structs"),
+        )),
+    }
+}
+
+fn to_member(field: &Field, index: usize) -> Member {
+    field
+        .ident
+        .as_ref()
+        .map(|name| Member::Named(name.clone()))
+        .unwrap_or_else(|| Member::Unnamed(Index::from(index)))
+}

vendor/bevy_derive/src/enum_variant_meta.rs

@@ -0,0 +1,40 @@
+use proc_macro::{Span, TokenStream};
+use quote::quote;
+use syn::{parse_macro_input, Data, DeriveInput};
+
+pub fn derive_enum_variant_meta(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let variants = match &ast.data {
+        Data::Enum(v) => &v.variants,
+        _ => {
+            return syn::Error::new(Span::call_site().into(), "Only enums are supported")
+                .into_compile_error()
+                .into()
+        }
+    };
+
+    let generics = ast.generics;
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let struct_name = &ast.ident;
+    let idents = variants.iter().map(|v| &v.ident);
+    let names = variants.iter().map(|v| v.ident.to_string());
+    let indices = 0..names.len();
+
+    TokenStream::from(quote! {
+        impl #impl_generics #struct_name #ty_generics #where_clause {
+            pub fn enum_variant_index(&self) -> usize {
+                match self {
+                    #(#struct_name::#idents {..} => #indices,)*
+                }
+            }
+            pub fn enum_variant_name(&self) -> &'static str {
+                static variants: &[&str] = &[
+                    #(#names,)*
+                ];
+                let index = self.enum_variant_index();
+                variants[index]
+            }
+        }
+    })
+}

vendor/bevy_derive/src/lib.rs

@@ -0,0 +1,212 @@
+#![expect(missing_docs, reason = "Not all docs are written yet, see #3492.")]
+#![forbid(unsafe_code)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc(
+    html_logo_url = "https://bevyengine.org/assets/icon.png",
+    html_favicon_url = "https://bevyengine.org/assets/icon.png"
+)]
+
+extern crate proc_macro;
+
+mod bevy_main;
+mod derefs;
+mod enum_variant_meta;
+
+use bevy_macro_utils::{derive_label, BevyManifest};
+use proc_macro::TokenStream;
+use quote::format_ident;
+
+/// Implements [`Deref`] for structs. This is especially useful when utilizing the [newtype] pattern.
+///
+/// For single-field structs, the implementation automatically uses that field.
+/// For multi-field structs, you must specify which field to use with the `#[deref]` attribute.
+///
+/// If you need [`DerefMut`] as well, consider using the other [derive] macro alongside
+/// this one.
+///
+/// # Example
+///
+/// ## Tuple Structs
+///
+/// Using a single-field struct:
+///
+/// ```
+/// use bevy_derive::Deref;
+///
+/// #[derive(Deref)]
+/// struct MyNewtype(String);
+///
+/// let foo = MyNewtype(String::from("Hello"));
+/// assert_eq!("Hello", *foo);
+/// ```
+///
+/// Using a multi-field struct:
+///
+/// ```
+/// # use std::marker::PhantomData;
+/// use bevy_derive::Deref;
+///
+/// #[derive(Deref)]
+/// struct MyStruct<T>(#[deref] String, PhantomData<T>);
+///
+/// let foo = MyStruct(String::from("Hello"), PhantomData::<usize>);
+/// assert_eq!("Hello", *foo);
+/// ```
+///
+/// ## Named Structs
+///
+/// Using a single-field struct:
+///
+/// ```
+/// use bevy_derive::{Deref, DerefMut};
+///
+/// #[derive(Deref, DerefMut)]
+/// struct MyStruct {
+///   value: String,
+/// }
+///
+/// let foo = MyStruct {
+///   value: String::from("Hello")
+/// };
+/// assert_eq!("Hello", *foo);
+/// ```
+///
+/// Using a multi-field struct:
+///
+/// ```
+/// # use std::marker::PhantomData;
+/// use bevy_derive::{Deref, DerefMut};
+///
+/// #[derive(Deref, DerefMut)]
+/// struct MyStruct<T> {
+///   #[deref]
+///   value: String,
+///   _phantom: PhantomData<T>,
+/// }
+///
+/// let foo = MyStruct {
+///   value:String::from("Hello"),
+///   _phantom:PhantomData::<usize>
+/// };
+/// assert_eq!("Hello", *foo);
+/// ```
+///
+/// [`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, attributes(deref))]
+pub fn derive_deref(input: TokenStream) -> TokenStream {
+    derefs::derive_deref(input)
+}
+
+/// Implements [`DerefMut`] for structs. This is especially useful when utilizing the [newtype] pattern.
+///
+/// For single-field structs, the implementation automatically uses that field.
+/// For multi-field structs, you must specify which field to use with the `#[deref]` attribute.
+///
+/// [`DerefMut`] requires a [`Deref`] implementation. You can implement it manually or use
+/// Bevy's [derive] macro for convenience.
+///
+/// # Example
+///
+/// ## Tuple Structs
+///
+/// Using a single-field struct:
+///
+/// ```
+/// 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);
+/// ```
+///
+/// Using a multi-field struct:
+///
+/// ```
+/// # use std::marker::PhantomData;
+/// use bevy_derive::{Deref, DerefMut};
+///
+/// #[derive(Deref, DerefMut)]
+/// struct MyStruct<T>(#[deref] String, PhantomData<T>);
+///
+/// let mut foo = MyStruct(String::from("Hello"), PhantomData::<usize>);
+/// foo.push_str(" World!");
+/// assert_eq!("Hello World!", *foo);
+/// ```
+///
+/// ## Named Structs
+///
+/// Using a single-field struct:
+///
+/// ```
+/// use bevy_derive::{Deref, DerefMut};
+///
+/// #[derive(Deref, DerefMut)]
+/// struct MyStruct {
+///   value: String,
+/// }
+///
+/// let mut foo = MyStruct {
+///   value: String::from("Hello")
+/// };
+/// foo.push_str(" World!");
+/// assert_eq!("Hello World!", *foo);
+/// ```
+///
+/// Using a multi-field struct:
+///
+/// ```
+/// # use std::marker::PhantomData;
+/// use bevy_derive::{Deref, DerefMut};
+///
+/// #[derive(Deref, DerefMut)]
+/// struct MyStruct<T> {
+///   #[deref]
+///   value: String,
+///   _phantom: PhantomData<T>,
+/// }
+///
+/// let mut foo = MyStruct {
+///   value:String::from("Hello"),
+///   _phantom:PhantomData::<usize>
+/// };
+/// 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, attributes(deref))]
+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 does not work for unions.
+#[proc_macro_derive(AppLabel)]
+pub fn derive_app_label(input: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(input as syn::DeriveInput);
+    let mut trait_path = BevyManifest::shared().get_path("bevy_app");
+    let mut dyn_eq_path = trait_path.clone();
+    trait_path.segments.push(format_ident!("AppLabel").into());
+    dyn_eq_path.segments.push(format_ident!("DynEq").into());
+    derive_label(input, "AppLabel", &trait_path, &dyn_eq_path)
+}