using an associate constant of Resource to mark setup resources

Author: mockersf

crates/bevy_app/src/app.rs

@@ -671,25 +671,33 @@ impl App {
     /// A setup resource is used at startup for plugin initialisation and configuration.
     /// All setup resources inserted must be consumed by a plugin and removed before the
     /// application is ran.
-    pub fn insert_setup_resource<T>(&mut self, resource: T) -> &mut Self
+    pub fn insert_setup_resource<R>(&mut self, resource: R) -> &mut Self
     where
-        T: Resource,
+        R: Resource,
     {
-        self.setup_resources
-            .insert(std::any::TypeId::of::<T>(), std::any::type_name::<T>());
-        self.insert_resource(Setup(resource));
+        if R::IS_SETUP_RESOURCE {
+            self.setup_resources
+                .insert(std::any::TypeId::of::<R>(), std::any::type_name::<R>());
+            self.insert_resource(Setup(resource));
+        } else {
+            // Using `eprintln` here as this is supposed to be called before logs are set up
+            eprintln!(
+                "Resource {} is not a setup resource",
+                std::any::type_name::<R>()
+            );
+        }
         self
     }
 
     /// Consumes a setup resource, and removes it from the current [App] so that a plugin
     /// can use it for its setup.
-    pub fn consume_setup_resource<T>(&mut self) -> Option<T>
+    pub fn consume_setup_resource<R>(&mut self) -> Option<R>
     where
-        T: Resource,
+        R: Resource,
     {
-        self.setup_resources.remove(&std::any::TypeId::of::<T>());
+        self.setup_resources.remove(&std::any::TypeId::of::<R>());
         self.world
-            .remove_resource::<Setup<T>>()
+            .remove_resource::<Setup<R>>()
             .map(|setup| setup.0)
     }
 

crates/bevy_asset/src/lib.rs

@@ -68,6 +68,7 @@ pub struct AssetPlugin;
 ///
 /// This resource must be added before the [`AssetPlugin`] or `DefaultPlugins` to take effect.
 #[derive(Resource)]
+#[resource(setup)]
 pub struct AssetServerSettings {
     /// The base folder where assets are loaded from, relative to the executable.
     pub asset_folder: String,

crates/bevy_core/src/task_pool_options.rs

@@ -35,6 +35,7 @@ impl TaskPoolThreadAssignmentPolicy {
 /// insert the default task pools into the resource map manually. If the pools are already inserted,
 /// this helper will do nothing.
 #[derive(Clone, Resource)]
+#[resource(setup)]
 pub struct DefaultTaskPoolOptions {
     /// If the number of physical cores is less than min_total_threads, force using
     /// min_total_threads

crates/bevy_ecs/macros/src/component.rs

@@ -4,24 +4,6 @@ use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{quote, ToTokens};
 use syn::{parse_macro_input, parse_quote, DeriveInput, Error, Ident, Path, Result};
 
-pub fn derive_resource(input: TokenStream) -> TokenStream {
-    let mut ast = parse_macro_input!(input as DeriveInput);
-    let bevy_ecs_path: Path = crate::bevy_ecs_path();
-
-    ast.generics
-        .make_where_clause()
-        .predicates
-        .push(parse_quote! { Self: Send + Sync + 'static });
-
-    let struct_name = &ast.ident;
-    let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
-
-    TokenStream::from(quote! {
-        impl #impl_generics #bevy_ecs_path::system::Resource for #struct_name #type_generics #where_clause {
-        }
-    })
-}
-
 pub fn derive_component(input: TokenStream) -> TokenStream {
     let mut ast = parse_macro_input!(input as DeriveInput);
     let bevy_ecs_path: Path = crate::bevy_ecs_path();

crates/bevy_ecs/macros/src/lib.rs

@@ -2,6 +2,7 @@ extern crate proc_macro;
 
 mod component;
 mod fetch;
+mod resource;
 
 use crate::fetch::derive_world_query_impl;
 use bevy_macro_utils::{derive_label, get_named_struct_fields, BevyManifest};
@@ -496,9 +497,9 @@ pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::default().get_path("bevy_ecs")
 }
 
-#[proc_macro_derive(Resource)]
+#[proc_macro_derive(Resource, attributes(resource))]
 pub fn derive_resource(input: TokenStream) -> TokenStream {
-    component::derive_resource(input)
+    resource::derive_resource(input)
 }
 
 #[proc_macro_derive(Component, attributes(component))]

crates/bevy_ecs/macros/src/resource.rs

@@ -0,0 +1,73 @@
+use bevy_macro_utils::Symbol;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::{quote, ToTokens};
+use syn::{parse_macro_input, parse_quote, DeriveInput, Error, Ident, Path, Result};
+
+pub fn derive_resource(input: TokenStream) -> TokenStream {
+    let mut ast = parse_macro_input!(input as DeriveInput);
+    let bevy_ecs_path: Path = crate::bevy_ecs_path();
+
+    let attrs = match parse_resource_attr(&ast) {
+        Ok(attrs) => attrs,
+        Err(e) => return e.into_compile_error().into(),
+    };
+
+    let is_setup_resource = Ident::new(&format!("{}", attrs.is_setup_resource), Span::call_site());
+
+    ast.generics
+        .make_where_clause()
+        .predicates
+        .push(parse_quote! { Self: Send + Sync + 'static });
+
+    let struct_name = &ast.ident;
+    let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics #bevy_ecs_path::system::Resource for #struct_name #type_generics #where_clause {
+            const IS_SETUP_RESOURCE: bool = #is_setup_resource;
+        }
+    })
+}
+
+pub const RESOURCE: Symbol = Symbol("resource");
+pub const SETUP_RESOURCE: Symbol = Symbol("setup");
+
+struct Attrs {
+    is_setup_resource: bool,
+}
+
+fn parse_resource_attr(ast: &DeriveInput) -> Result<Attrs> {
+    let meta_items = bevy_macro_utils::parse_attrs(ast, RESOURCE)?;
+
+    let mut attrs = Attrs {
+        is_setup_resource: false,
+    };
+
+    for meta in meta_items {
+        use syn::{
+            Meta::Path,
+            NestedMeta::{Lit, Meta},
+        };
+        match meta {
+            Meta(Path(m)) if m == SETUP_RESOURCE => attrs.is_setup_resource = true,
+            Meta(meta_item) => {
+                return Err(Error::new_spanned(
+                    meta_item.path(),
+                    format!(
+                        "unknown component attribute `{}`",
+                        meta_item.path().into_token_stream()
+                    ),
+                ));
+            }
+            Lit(lit) => {
+                return Err(Error::new_spanned(
+                    lit,
+                    "unexpected literal in component attribute",
+                ))
+            }
+        }
+    }
+
+    Ok(attrs)
+}

crates/bevy_ecs/src/system/commands/mod.rs

@@ -373,9 +373,13 @@ impl<'w, 's> Commands<'w, 's> {
     /// # bevy_ecs::system::assert_is_system(initialise_scoreboard);
     /// ```
     pub fn init_resource<R: Resource + FromWorld>(&mut self) {
-        self.queue.push(InitResource::<R> {
-            _phantom: PhantomData::<R>::default(),
-        });
+        if !R::IS_SETUP_RESOURCE {
+            self.queue.push(InitResource::<R> {
+                _phantom: PhantomData::<R>::default(),
+            });
+        } else {
+            error!("Initializing resource {} during execution has no effect. It should be added during setup using `insert_setup_resource`.", std::any::type_name::<R>());
+        }
     }
 
     /// Inserts a resource to the [`World`], overwriting any previous value of the same type.
@@ -404,7 +408,11 @@ impl<'w, 's> Commands<'w, 's> {
     /// # bevy_ecs::system::assert_is_system(system);
     /// ```
     pub fn insert_resource<R: Resource>(&mut self, resource: R) {
-        self.queue.push(InsertResource { resource });
+        if !R::IS_SETUP_RESOURCE {
+            self.queue.push(InsertResource { resource });
+        } else {
+            error!("Inserting resource {} during execution has no effect. It should be added during setup using `insert_setup_resource`.", std::any::type_name::<R>());
+        }
     }
 
     /// Removes a resource from the [`World`].

crates/bevy_ecs/src/system/system_param.rs

@@ -252,7 +252,9 @@ impl_param_set!();
 /// # schedule.add_system_to_stage("update", write_resource_system.after("first"));
 /// # schedule.run_once(&mut world);
 /// ```
-pub trait Resource: Send + Sync + 'static {}
+pub trait Resource: Send + Sync + 'static {
+    const IS_SETUP_RESOURCE: bool = false;
+}
 
 /// Shared borrow of a [`Resource`].
 ///

crates/bevy_ecs/src/world/mod.rs

@@ -21,7 +21,7 @@ use crate::{
     system::Resource,
 };
 use bevy_ptr::{OwningPtr, Ptr, UnsafeCellDeref};
-use bevy_utils::tracing::debug;
+use bevy_utils::tracing::{debug, error};
 use std::{
     any::TypeId,
     fmt,
@@ -659,13 +659,20 @@ impl World {
     /// you will overwrite any existing data.
     #[inline]
     pub fn insert_resource<R: Resource>(&mut self, value: R) {
-        let component_id = self.components.init_resource::<R>();
-        OwningPtr::make(value, |ptr| {
-            // SAFETY: component_id was just initialized and corresponds to resource of type R
-            unsafe {
-                self.insert_resource_by_id(component_id, ptr);
-            }
-        });
+        if !R::IS_SETUP_RESOURCE {
+            let component_id = self.components.init_resource::<R>();
+            OwningPtr::make(value, |ptr| {
+                // SAFETY: component_id was just initialized and corresponds to resource of type R
+                unsafe {
+                    self.insert_resource_by_id(component_id, ptr);
+                }
+            });
+        } else {
+            error!(
+                "Inserting setup resource {} as a normal resource, ignoring",
+                std::any::type_name::<R>()
+            );
+        }
     }
 
     /// Inserts a new non-send resource with standard starting values.

crates/bevy_log/src/lib.rs

@@ -92,6 +92,7 @@ pub struct LogPlugin;
 
 /// `LogPlugin` settings
 #[derive(Resource)]
+#[resource(setup)]
 pub struct LogSettings {
     /// Filters logs using the [`EnvFilter`] format
     pub filter: String,

crates/bevy_render/src/texture/image.rs

@@ -162,6 +162,7 @@ impl ImageSampler {
 ///
 /// Can be set via `insert_setup_resource` during app initialization to change the default settings.
 #[derive(Resource)]
+#[resource(setup)]
 pub struct ImageSettings {
     /// The default image sampler to use when [`ImageSampler`] is set to `Default`.
     pub default_sampler: wgpu::SamplerDescriptor<'static>,

crates/bevy_window/src/event.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use super::{WindowId, WindowSetupDescriptor};
+use super::{WindowDescriptor, WindowId};
 use bevy_math::{IVec2, Vec2};
 
 /// A window event that is sent whenever a window's logical size has changed.
@@ -17,7 +17,7 @@ pub struct WindowResized {
 #[derive(Debug, Clone)]
 pub struct CreateWindow {
     pub id: WindowId,
-    pub descriptor: WindowSetupDescriptor,
+    pub descriptor: WindowDescriptor,
 }
 
 /// An event that indicates the window should redraw, even if its control flow is set to `Wait` and

crates/bevy_window/src/lib.rs

@@ -17,7 +17,7 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         CursorEntered, CursorIcon, CursorLeft, CursorMoved, FileDragAndDrop, MonitorSelection,
-        ReceivedCharacter, Window, WindowMode, WindowMoved, WindowPosition, WindowSetupDescriptor,
+        ReceivedCharacter, Window, WindowDescriptor, WindowMode, WindowMoved, WindowPosition,
         Windows,
     };
 }
@@ -99,7 +99,7 @@ impl Plugin for WindowPlugin {
 
         if settings.add_primary_window {
             let window_descriptor = app
-                .consume_setup_resource::<WindowSetupDescriptor>()
+                .consume_setup_resource::<WindowDescriptor>()
                 .unwrap_or_default();
             let mut create_window_event = app.world.resource_mut::<Events<CreateWindow>>();
             create_window_event.send(CreateWindow {

crates/bevy_window/src/window.rs

@@ -21,7 +21,7 @@ pub struct WindowId(Uuid);
 /// `Immediate` or `Mailbox` will gracefully fallback to `Fifo` when unavailable.
 ///
 /// The presentation mode may be declared in the
-/// [`WindowSetupDescriptor`](WindowSetupDescriptor::present_mode) or updated on a
+/// [`WindowDescriptor`](WindowDescriptor::present_mode) or updated on a
 /// [`Window`](Window::set_present_mode).
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -306,7 +306,7 @@ impl Window {
     /// Creates a new [`Window`].
     pub fn new(
         id: WindowId,
-        window_descriptor: &WindowSetupDescriptor,
+        window_descriptor: &WindowDescriptor,
         physical_width: u32,
         physical_height: u32,
         scale_factor: f64,
@@ -752,13 +752,13 @@ pub enum WindowPosition {
     Automatic,
     /// Center the window on the monitor.
     ///
-    /// The monitor to center the window on can be selected with the `monitor` field in `WindowSetupDescriptor`.
+    /// The monitor to center the window on can be selected with the `monitor` field in `WindowDescriptor`.
     Centered,
     /// The window's top-left corner will be placed at the specified position in pixels.
     ///
     /// (0,0) represents top-left corner of the monitor.
     ///
-    /// The monitor to position the window on can be selected with the `monitor` field in `WindowSetupDescriptor`.
+    /// The monitor to position the window on can be selected with the `monitor` field in `WindowDescriptor`.
     At(Vec2),
 }
 
@@ -784,7 +784,8 @@ pub enum MonitorSelection {
 ///
 /// [`examples/window/window_settings.rs`]: https://github.com/bevyengine/bevy/blob/latest/examples/window/window_settings.rs
 #[derive(Resource, Debug, Clone)]
-pub struct WindowSetupDescriptor {
+#[resource(setup)]
+pub struct WindowDescriptor {
     /// The requested logical width of the window's client area.
     ///
     /// May vary from the physical width due to different pixel density on different monitors.
@@ -862,9 +863,9 @@ pub struct WindowSetupDescriptor {
     pub fit_canvas_to_parent: bool,
 }
 
-impl Default for WindowSetupDescriptor {
+impl Default for WindowDescriptor {
     fn default() -> Self {
-        WindowSetupDescriptor {
+        WindowDescriptor {
             title: "app".to_string(),
             width: 1280.,
             height: 720.,

crates/bevy_winit/src/winit_windows.rs

@@ -1,6 +1,6 @@
 use bevy_math::{DVec2, IVec2};
 use bevy_utils::HashMap;
-use bevy_window::{MonitorSelection, Window, WindowId, WindowMode, WindowSetupDescriptor};
+use bevy_window::{MonitorSelection, Window, WindowDescriptor, WindowId, WindowMode};
 use raw_window_handle::HasRawWindowHandle;
 use winit::{
     dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize},
@@ -23,11 +23,11 @@ impl WinitWindows {
         &mut self,
         event_loop: &winit::event_loop::EventLoopWindowTarget<()>,
         window_id: WindowId,
-        window_descriptor: &WindowSetupDescriptor,
+        window_descriptor: &WindowDescriptor,
     ) -> Window {
         let mut winit_window_builder = winit::window::WindowBuilder::new();
 
-        let &WindowSetupDescriptor {
+        let &WindowDescriptor {
             width,
             height,
             position,

examples/ios/src/lib.rs

@@ -4,7 +4,7 @@ use bevy::{input::touch::TouchPhase, prelude::*, window::WindowMode};
 #[bevy_main]
 fn main() {
     App::new()
-        .insert_setup_resource(WindowSetupDescriptor {
+        .insert_setup_resource(WindowDescriptor {
             resizable: false,
             mode: WindowMode::BorderlessFullscreen,
             ..default()