Add on_unimplemented Diagnostics to Most Public Traits

Author: bushrat011899

Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["game", "engine", "gamedev", "graphics", "bevy"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/bevyengine/bevy"
 documentation = "https://docs.rs/bevy"
-rust-version = "1.77.0"
+rust-version = "1.78.0"
 
 [workspace]
 exclude = [

crates/bevy_animation/src/animatable.rs

@@ -16,6 +16,10 @@ pub struct BlendInput<T> {
 }
 
 /// An animatable value type.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not be animated",
+    label = "invalid animatable"
+)]
 pub trait Animatable: Reflect + Sized + Send + Sync + 'static {
     /// Interpolates between `a` and `b` with  a interpolation factor of `time`.
     ///

crates/bevy_app/src/plugin.rs

@@ -54,7 +54,8 @@ use std::any::Any;
 ///     }
 /// }
 /// # fn damp_flickering() {}
-/// ````
+/// ```
+#[diagnostic::on_unimplemented(message = "`{Self}` is not a plugin", label = "invalid plugin")]
 pub trait Plugin: Downcast + Any + Send + Sync {
     /// Configures the [`App`] to which this plugin is added.
     fn build(&self, app: &mut App);
@@ -130,6 +131,10 @@ pub type CreatePlugin = unsafe fn() -> *mut dyn Plugin;
 ///
 /// This is implemented for all types which implement [`Plugin`],
 /// [`PluginGroup`](super::PluginGroup), and tuples over [`Plugins`].
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not a set of plugins",
+    label = "invalid plugin set"
+)]
 pub trait Plugins<Marker>: sealed::Plugins<Marker> {}
 
 impl<Marker, T> Plugins<Marker> for T where T: sealed::Plugins<Marker> {}

crates/bevy_app/src/plugin_group.rs

@@ -3,6 +3,10 @@ use bevy_utils::{tracing::debug, tracing::warn, TypeIdMap};
 use std::any::TypeId;
 
 /// Combines multiple [`Plugin`]s into a single unit.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not a plugin group",
+    label = "invalid plugin group"
+)]
 pub trait PluginGroup: Sized {
     /// Configures the [`Plugin`]s that are to be added.
     fn build(self) -> PluginGroupBuilder;

crates/bevy_asset/src/direct_access_ext.rs

@@ -5,6 +5,7 @@ use bevy_ecs::world::World;
 
 use crate::{meta::Settings, Asset, AssetPath, AssetServer, Assets, Handle};
 
+#[diagnostic::on_unimplemented(message = "`{Self}` is not a World", label = "invalid world")]
 pub trait DirectAssetAccessExt {
     /// Insert an asset similarly to [`Assets::add`].
     fn add_asset<A: Asset>(&mut self, asset: impl Into<A>) -> Handle<A>;

crates/bevy_asset/src/io/mod.rs

@@ -72,6 +72,10 @@ impl From<std::io::Error> for AssetReaderError {
     }
 }
 
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asynchronous and seekable reader",
+    label = "invalid reader"
+)]
 pub trait AsyncReadAndSeek: AsyncRead + AsyncSeek {}
 
 impl<T: AsyncRead + AsyncSeek> AsyncReadAndSeek for T {}
@@ -83,6 +87,10 @@ pub type Reader<'a> = dyn AsyncReadAndSeek + Unpin + Send + Sync + 'a;
 /// `path`. This trait is not object safe, if needed use a dyn [`ErasedAssetReader`] instead.
 ///
 /// Also see [`AssetWriter`].
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset reader",
+    label = "invalid asset reader"
+)]
 pub trait AssetReader: Send + Sync + 'static {
     /// Returns a future to load the full file data at the provided path.
     fn read<'a>(
@@ -121,6 +129,10 @@ pub trait AssetReader: Send + Sync + 'static {
 
 /// Equivalent to an [`AssetReader`] but using boxed futures, necessary eg. when using a `dyn AssetReader`,
 /// as [`AssetReader`] isn't currently object safe.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an erasable asset reader",
+    label = "invalid asset reader"
+)]
 pub trait ErasedAssetReader: Send + Sync + 'static {
     /// Returns a future to load the full file data at the provided path.
     fn read<'a>(&'a self, path: &'a Path)
@@ -192,6 +204,10 @@ pub enum AssetWriterError {
 /// `path`. This trait is not object safe, if needed use a dyn [`ErasedAssetWriter`] instead.
 ///
 /// Also see [`AssetReader`].
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset writer",
+    label = "invalid asset writer"
+)]
 pub trait AssetWriter: Send + Sync + 'static {
     /// Writes the full asset bytes at the provided path.
     fn write<'a>(
@@ -274,6 +290,10 @@ pub trait AssetWriter: Send + Sync + 'static {
 
 /// Equivalent to an [`AssetWriter`] but using boxed futures, necessary eg. when using a `dyn AssetWriter`,
 /// as [`AssetWriter`] isn't currently object safe.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an erasable asset writer",
+    label = "invalid asset writer"
+)]
 pub trait ErasedAssetWriter: Send + Sync + 'static {
     /// Writes the full asset bytes at the provided path.
     fn write<'a>(&'a self, path: &'a Path) -> BoxedFuture<Result<Box<Writer>, AssetWriterError>>;
@@ -429,6 +449,10 @@ pub enum AssetSourceEvent {
 
 /// A handle to an "asset watcher" process, that will listen for and emit [`AssetSourceEvent`] values for as long as
 /// [`AssetWatcher`] has not been dropped.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset watcher",
+    label = "invalid asset watcher"
+)]
 pub trait AssetWatcher: Send + Sync + 'static {}
 
 /// An [`AsyncRead`] implementation capable of reading a [`Vec<u8>`].

crates/bevy_asset/src/lib.rs

@@ -223,8 +223,17 @@ impl Plugin for AssetPlugin {
     }
 }
 
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset",
+    label = "invalid asset",
+    note = "consider annotating `{Self}` with `#[derive(Asset)]`"
+)]
 pub trait Asset: VisitAssetDependencies + TypePath + Send + Sync + 'static {}
 
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not visit dependencies",
+    label = "invalid asset"
+)]
 pub trait VisitAssetDependencies {
     fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId));
 }
@@ -274,6 +283,7 @@ impl VisitAssetDependencies for Vec<UntypedHandle> {
 }
 
 /// Adds asset-related builder methods to [`App`].
+#[diagnostic::on_unimplemented(message = "`{Self}` is not an App", label = "invalid `App`")]
 pub trait AssetApp {
     /// Registers the given `loader` in the [`App`]'s [`AssetServer`].
     fn register_asset_loader<L: AssetLoader>(&mut self, loader: L) -> &mut Self;

crates/bevy_asset/src/loader.rs

@@ -22,6 +22,10 @@ use thiserror::Error;
 
 /// Loads an [`Asset`] from a given byte [`Reader`]. This can accept [`AssetLoader::Settings`], which configure how the [`Asset`]
 /// should be loaded.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset loader",
+    label = "invalid asset loader"
+)]
 pub trait AssetLoader: Send + Sync + 'static {
     /// The top level [`Asset`] loaded by this [`AssetLoader`].
     type Asset: crate::Asset;
@@ -45,6 +49,10 @@ pub trait AssetLoader: Send + Sync + 'static {
 }
 
 /// Provides type-erased access to an [`AssetLoader`].
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an erasable asset loader",
+    label = "invalid asset loader"
+)]
 pub trait ErasedAssetLoader: Send + Sync + 'static {
     /// Asynchronously loads the asset(s) from the bytes provided by [`Reader`].
     fn load<'a>(
@@ -231,6 +239,10 @@ impl ErasedLoadedAsset {
 }
 
 /// A type erased container for an [`Asset`] value that is capable of inserting the [`Asset`] into a [`World`]'s [`Assets`] collection.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset container",
+    label = "invalid container"
+)]
 pub trait AssetContainer: Downcast + Any + Send + Sync + 'static {
     fn insert(self: Box<Self>, id: UntypedAssetId, world: &mut World);
     fn asset_type_name(&self) -> &'static str;

crates/bevy_asset/src/meta.rs

@@ -114,6 +114,10 @@ pub struct ProcessedInfoMinimal {
 
 /// A dynamic type-erased counterpart to [`AssetMeta`] that enables passing around and interacting with [`AssetMeta`] without knowing
 /// its type.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not be used as an erased AssetMeta",
+    label = "invalid asset meta"
+)]
 pub trait AssetMetaDyn: Downcast + Send + Sync {
     /// Returns a reference to the [`AssetLoader`] settings, if they exist.
     fn loader_settings(&self) -> Option<&dyn Settings>;
@@ -160,6 +164,10 @@ impl_downcast!(AssetMetaDyn);
 /// Settings used by the asset system, such as by [`AssetLoader`], [`Process`], and [`AssetSaver`]
 ///
 /// [`AssetSaver`]: crate::saver::AssetSaver
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not be used as an asset setting",
+    label = "invalid settings"
+)]
 pub trait Settings: Downcast + Send + Sync + 'static {}
 
 impl<T: 'static> Settings for T where T: Send + Sync {}

crates/bevy_asset/src/processor/process.rs

@@ -21,6 +21,10 @@ use thiserror::Error;
 ///
 /// This is a "low level", maximally flexible interface. Most use cases are better served by the [`LoadTransformAndSave`] implementation
 /// of [`Process`].
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not process assets",
+    label = "invalid asset process"
+)]
 pub trait Process: Send + Sync + Sized + 'static {
     /// The configuration / settings used to process the asset. This will be stored in the [`AssetMeta`] and is user-configurable per-asset.
     type Settings: Settings + Default + Serialize + for<'a> Deserialize<'a>;
@@ -243,6 +247,10 @@ impl<Loader: AssetLoader, Saver: AssetSaver<Asset = Loader::Asset>> Process
 
 /// A type-erased variant of [`Process`] that enables interacting with processor implementations without knowing
 /// their type.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not be erased",
+    label = "invalid asset process"
+)]
 pub trait ErasedProcessor: Send + Sync {
     /// Type-erased variant of [`Process::process`].
     fn process<'a>(