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 = "Try using `#[derive(Asset)]`"
+)]
 pub trait Asset: VisitAssetDependencies + TypePath + Send + Sync + 'static {}
 
+#[diagnostic::on_unimplemented(
+    message = "Can not visit dependencies on `{Self}`",
+    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>(

crates/bevy_asset/src/saver.rs

@@ -7,6 +7,10 @@ use std::{borrow::Borrow, hash::Hash, ops::Deref};
 
 /// Saves an [`Asset`] of a given [`AssetSaver::Asset`] type. [`AssetSaver::OutputLoader`] will then be used to load the saved asset
 /// in the final deployed application. The saver should produce asset bytes in a format that [`AssetSaver::OutputLoader`] can read.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset saver",
+    label = "Invalid Asset Saver"
+)]
 pub trait AssetSaver: Send + Sync + 'static {
     /// The top level [`Asset`] saved by this [`AssetSaver`].
     type Asset: Asset;
@@ -30,6 +34,10 @@ pub trait AssetSaver: Send + Sync + 'static {
 }
 
 /// A type-erased dynamic variant of [`AssetSaver`] that allows callers to save assets without knowing the actual type of the [`AssetSaver`].
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an erasable asset saver",
+    label = "Invalid Asset Saver"
+)]
 pub trait ErasedAssetSaver: Send + Sync + 'static {
     /// Saves the given runtime [`ErasedLoadedAsset`] by writing it to a byte format using `writer`. The passed in `settings` can influence how the
     /// `asset` is saved.  

crates/bevy_asset/src/transformer.rs

@@ -8,6 +8,10 @@ use std::{
 };
 
 /// Transforms an [`Asset`] of a given [`AssetTransformer::AssetInput`] type to an [`Asset`] of [`AssetTransformer::AssetOutput`] type.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an asset transformer",
+    label = "Invalid Asset Transformer"
+)]
 pub trait AssetTransformer: Send + Sync + 'static {
     /// The [`Asset`] type which this [`AssetTransformer`] takes as and input.
     type AssetInput: Asset;

crates/bevy_audio/src/audio_source.rs

@@ -80,6 +80,10 @@ impl AssetLoader for AudioLoader {
 /// Types that implement this trait usually contain raw sound data that can be converted into an iterator of samples.
 /// This trait is implemented for [`AudioSource`].
 /// Check the example [`decodable`](https://github.com/bevyengine/bevy/blob/latest/examples/audio/decodable.rs) for how to implement this trait on a custom type.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not a decodable audio source",
+    label = "Invalid Source"
+)]
 pub trait Decodable: Send + Sync + 'static {
     /// The type of the audio samples.
     /// Usually a [`u16`], [`i16`] or [`f32`], as those implement [`rodio::Sample`].
@@ -106,6 +110,7 @@ impl Decodable for AudioSource {
 
 /// A trait that allows adding a custom audio source to the object.
 /// This is implemented for [`App`][bevy_app::App] to allow registering custom [`Decodable`] types.
+#[diagnostic::on_unimplemented(message = "`{Self}` is not an App", label = "Invalid App")]
 pub trait AddAudioSource {
     /// Registers an audio source.
     /// The type must implement [`Decodable`],

crates/bevy_audio/src/sinks.rs

@@ -4,6 +4,10 @@ use bevy_transform::prelude::Transform;
 use rodio::{Sink, SpatialSink};
 
 /// Common interactions with an audio sink.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an audio sink",
+    label = "Invalid Audio Sink"
+)]
 pub trait AudioSinkPlayback {
     /// Gets the volume of the sound.
     ///

crates/bevy_color/src/color_difference.rs

@@ -2,6 +2,10 @@
 
 /// Calculate the distance between this and another color as if they were coordinates
 /// in a Euclidean space. Alpha is not considered in the distance calculation.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` does not have a definition for distance",
+    label = "Invalid Color Model"
+)]
 pub trait EuclideanDistance: Sized {
     /// Distance from `self` to `other`.
     fn distance(&self, other: &Self) -> f32 {

crates/bevy_color/src/color_ops.rs

@@ -3,6 +3,10 @@ use bevy_math::{Vec3, Vec4};
 /// Methods for changing the luminance of a color. Note that these methods are not
 /// guaranteed to produce consistent results across color spaces,
 /// but will be within a given space.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` does not have a definition of luminance",
+    label = "Non-Luminance Color Model"
+)]
 pub trait Luminance: Sized {
     /// Return the luminance of this color (0.0 - 1.0).
     fn luminance(&self) -> f32;
@@ -30,6 +34,10 @@ pub trait Luminance: Sized {
 }
 
 /// Linear interpolation of two colors within a given color space.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` can not be mixed",
+    label = "Unmixable Color Model"
+)]
 pub trait Mix: Sized {
     /// Linearly interpolate between this and another color, by factor.
     /// Factor should be between 0.0 and 1.0.
@@ -43,6 +51,10 @@ pub trait Mix: Sized {
 }
 
 /// Methods for manipulating alpha values.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` does not have an alpha channel",
+    label = "Opaque Color Model"
+)]
 pub trait Alpha: Sized {
     /// Return a new version of this color with the given alpha value.
     fn with_alpha(&self, alpha: f32) -> Self;
@@ -65,6 +77,10 @@ pub trait Alpha: Sized {
 }
 
 /// Trait for manipulating the hue of a color.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` does not have a definition of hue",
+    label = "Non-Hue Color Model"
+)]
 pub trait Hue: Sized {
     /// Return a new version of this color with the hue channel set to the given value.
     fn with_hue(&self, hue: f32) -> Self;
@@ -83,6 +99,10 @@ pub trait Hue: Sized {
 }
 
 /// Trait with methods for converting colors to non-color types
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` cannot be decomposed into color components",
+    label = "Invalid Color Model"
+)]
 pub trait ColorToComponents {
     /// Convert to an f32 array
     fn to_f32_array(self) -> [f32; 4];

crates/bevy_color/src/color_range.rs

@@ -7,6 +7,10 @@ use crate::Mix;
 /// implements [`Mix`].
 ///
 /// This is useful for defining gradients or animated color transitions.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not a valid color range",
+    label = "Invalid Color Range"
+)]
 pub trait ColorRange<T: Mix> {
     /// Get the color value at the given interpolation factor, which should be between 0.0 (start)
     /// and 1.0 (end).

crates/bevy_diagnostic/src/diagnostic.rs

@@ -382,6 +382,7 @@ impl SystemBuffer for DiagnosticsBuffer {
 }
 
 /// Extend [`App`] with new `register_diagnostic` function.
+#[diagnostic::on_unimplemented(message = "`{Self}` is not an App", label = "Invalid App")]
 pub trait RegisterDiagnostic {
     /// Register a new [`Diagnostic`] with an [`App`].
     ///

crates/bevy_dynamic_plugin/src/loader.rs

@@ -51,6 +51,7 @@ pub unsafe fn dynamically_load_plugin<P: AsRef<OsStr>>(
 }
 
 /// An extension trait for [`App`] that allows loading dynamic plugins.
+#[diagnostic::on_unimplemented(message = "`{Self}` is not an App", label = "Invalid App")]
 pub trait DynamicPluginExt {
     /// Dynamically links a plugin at the given path, registering the plugin.
     ///

crates/bevy_ecs/src/bundle.rs

@@ -165,6 +165,10 @@ pub unsafe trait Bundle: DynamicBundle + Send + Sync + 'static {
 }
 
 /// The parts from [`Bundle`] that don't require statically knowing the components of the bundle.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not a dynamic component bundle",
+    label = "Invalid Bundle"
+)]
 pub trait DynamicBundle {
     // SAFETY:
     // The `StorageType` argument passed into [`Bundle::get_components`] must be correct for the