Harden proc macro path resolution and add integration tests. (#17330)

This pr uses the `extern crate self as` trick to make proc macros behave
the same way inside and outside bevy.

# Objective

- Removes noise introduced by `crate as` in the whole bevy repo.
- Fixes #17004.
- Hardens proc macro path resolution.

## TODO

- [x] `BevyManifest` needs cleanup.
- [x] Cleanup remaining `crate as`.
- [x] Add proper integration tests to the ci.

## Notes

- `cargo-manifest-proc-macros` is written by me and based/inspired by
the old `BevyManifest` implementation and
[`bkchr/proc-macro-crate`](https://github.com/bkchr/proc-macro-crate).
- What do you think about the new integration test machinery I added to
the `ci`?
  More and better integration tests can be added at a later stage.
The goal of these integration tests is to simulate an actual separate
crate that uses bevy. Ideally they would lightly touch all bevy crates.

## Testing

- Needs RA test
- Needs testing from other users
- Others need to run at least `cargo run -p ci integration-test` and
verify that they work.

---------

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>

.gitignore

@@ -7,6 +7,7 @@ crates/**/target
 benches/**/target
 tools/**/target
 **/*.rs.bk
+rustc-ice-*.txt
 
 # DX12 wgpu backend
 dxcompiler.dll

Cargo.toml

@@ -29,6 +29,10 @@ members = [
   # Bevy's error codes. This is a crate so we can automatically check all of the code blocks.
   "errors",
 ]
+exclude = [
+  # Integration tests are not part of the workspace
+  "tests-integration",
+]
 
 [workspace.lints.clippy]
 doc_markdown = "warn"
@@ -494,6 +498,13 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 bytemuck = "1.7"
 bevy_render = { path = "crates/bevy_render", version = "0.16.0-dev", default-features = false }
+# The following explicit dependencies are needed for proc macros to work inside of examples as they are part of the bevy crate itself.
+bevy_ecs = { path = "crates/bevy_ecs", version = "0.16.0-dev", default-features = false }
+bevy_state = { path = "crates/bevy_state", version = "0.16.0-dev", default-features = false }
+bevy_asset = { path = "crates/bevy_asset", version = "0.16.0-dev", default-features = false }
+bevy_reflect = { path = "crates/bevy_reflect", version = "0.16.0-dev", default-features = false }
+bevy_image = { path = "crates/bevy_image", version = "0.16.0-dev", default-features = false }
+bevy_gizmos = { path = "crates/bevy_gizmos", version = "0.16.0-dev", default-features = false }
 # Needed to poll Task examples
 futures-lite = "2.0.1"
 async-std = "1.13"

benches/benches/bevy_ecs/change_detection.rs

@@ -267,7 +267,7 @@ fn none_changed_detection(criterion: &mut Criterion) {
     }
 }
 fn insert_if_bit_enabled<const B: u16>(entity: &mut EntityWorldMut, i: u16) {
-    if i & 1 << B != 0 {
+    if i & (1 << B) != 0 {
         entity.insert(Data::<B>(1.0));
     }
 }

benches/benches/bevy_ecs/components/archetype_updates.rs

@@ -22,7 +22,7 @@ fn setup(system_count: usize) -> (World, Schedule) {
 }
 
 fn insert_if_bit_enabled<const B: u16>(entity: &mut EntityWorldMut, i: u16) {
-    if i & 1 << B != 0 {
+    if i & (1 << B) != 0 {
         entity.insert(A::<B>(1.0));
     }
 }

benches/benches/bevy_ecs/empty_archetypes.rs

@@ -105,49 +105,49 @@ fn add_archetypes(world: &mut World, count: u16) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        if i & 1 << 1 != 0 {
+        if i & (1 << 1) != 0 {
             e.insert(A::<13>(1.0));
         }
-        if i & 1 << 2 != 0 {
+        if i & (1 << 2) != 0 {
             e.insert(A::<14>(1.0));
         }
-        if i & 1 << 3 != 0 {
+        if i & (1 << 3) != 0 {
             e.insert(A::<15>(1.0));
         }
-        if i & 1 << 4 != 0 {
+        if i & (1 << 4) != 0 {
             e.insert(A::<16>(1.0));
         }
-        if i & 1 << 5 != 0 {
+        if i & (1 << 5) != 0 {
             e.insert(A::<18>(1.0));
         }
-        if i & 1 << 6 != 0 {
+        if i & (1 << 6) != 0 {
             e.insert(A::<19>(1.0));
         }
-        if i & 1 << 7 != 0 {
+        if i & (1 << 7) != 0 {
             e.insert(A::<20>(1.0));
         }
-        if i & 1 << 8 != 0 {
+        if i & (1 << 8) != 0 {
             e.insert(A::<21>(1.0));
         }
-        if i & 1 << 9 != 0 {
+        if i & (1 << 9) != 0 {
             e.insert(A::<22>(1.0));
         }
-        if i & 1 << 10 != 0 {
+        if i & (1 << 10) != 0 {
             e.insert(A::<23>(1.0));
         }
-        if i & 1 << 11 != 0 {
+        if i & (1 << 11) != 0 {
             e.insert(A::<24>(1.0));
         }
-        if i & 1 << 12 != 0 {
+        if i & (1 << 12) != 0 {
             e.insert(A::<25>(1.0));
         }
-        if i & 1 << 13 != 0 {
+        if i & (1 << 13) != 0 {
             e.insert(A::<26>(1.0));
         }
-        if i & 1 << 14 != 0 {
+        if i & (1 << 14) != 0 {
             e.insert(A::<27>(1.0));
         }
-        if i & 1 << 15 != 0 {
+        if i & (1 << 15) != 0 {
             e.insert(A::<28>(1.0));
         }
     }

benches/benches/bevy_ecs/iteration/par_iter_simple.rs

@@ -19,7 +19,7 @@ struct Data<const X: u16>(f32);
 pub struct Benchmark<'w>(World, QueryState<(&'w Velocity, &'w mut Position)>);
 
 fn insert_if_bit_enabled<const B: u16>(entity: &mut EntityWorldMut, i: u16) {
-    if i & 1 << B != 0 {
+    if i & (1 << B) != 0 {
         entity.insert(Data::<B>(1.0));
     }
 }

crates/bevy_app/src/app.rs

@@ -1532,7 +1532,6 @@ mod tests {
     #[test]
     fn test_derive_app_label() {
         use super::AppLabel;
-        use crate::{self as bevy_app};
 
         #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
         struct UnitLabel;
@@ -1664,7 +1663,6 @@ mod tests {
     #[test]
     fn test_extract_sees_changes() {
         use super::AppLabel;
-        use crate::{self as bevy_app};
 
         #[derive(AppLabel, Clone, Copy, Hash, PartialEq, Eq, Debug)]
         struct MySubApp;

crates/bevy_app/src/lib.rs

@@ -20,6 +20,9 @@ extern crate std;
 
 extern crate alloc;
 
+// Required to make proc macros work in bevy itself.
+extern crate self as bevy_app;
+
 mod app;
 mod main_schedule;
 mod panic_handler;

crates/bevy_asset/src/asset_changed.rs

@@ -282,7 +282,7 @@ unsafe impl<A: AsAssetId> QueryFilter for AssetChanged<A> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{self as bevy_asset, AssetEvents, AssetPlugin, Handle};
+    use crate::{AssetEvents, AssetPlugin, Handle};
     use alloc::{vec, vec::Vec};
     use core::num::NonZero;
     use std::println;

crates/bevy_asset/src/assets.rs

@@ -1,8 +1,5 @@
 use crate::asset_changed::AssetChanges;
-use crate::{
+use crate::{Asset, AssetEvent, AssetHandleProvider, AssetId, AssetServer, Handle, UntypedHandle};
-    self as bevy_asset, Asset, AssetEvent, AssetHandleProvider, AssetId, AssetServer, Handle,
-    UntypedHandle,
-};
 use alloc::{sync::Arc, vec::Vec};
 use bevy_ecs::{
     prelude::EventWriter,

crates/bevy_asset/src/folder.rs

@@ -1,6 +1,5 @@
 use alloc::vec::Vec;
 
-use crate as bevy_asset;
 use crate::{Asset, UntypedHandle};
 use bevy_reflect::TypePath;
 

crates/bevy_asset/src/lib.rs

@@ -149,6 +149,9 @@
 extern crate alloc;
 extern crate std;
 
+// Required to make proc macros work in bevy itself.
+extern crate self as bevy_asset;
+
 pub mod io;
 pub mod meta;
 pub mod processor;
@@ -627,7 +630,6 @@ pub struct AssetEvents;
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_asset,
         folder::LoadedFolder,
         handle::Handle,
         io::{

crates/bevy_asset/src/meta.rs

@@ -5,8 +5,8 @@ use alloc::{
 };
 
 use crate::{
-    self as bevy_asset, loader::AssetLoader, processor::Process, Asset, AssetPath,
+    loader::AssetLoader, processor::Process, Asset, AssetPath, DeserializeMetaError,
-    DeserializeMetaError, VisitAssetDependencies,
+    VisitAssetDependencies,
 };
 use downcast_rs::{impl_downcast, Downcast};
 use ron::ser::PrettyConfig;

crates/bevy_asset/src/reflect.rs

@@ -247,7 +247,6 @@ mod tests {
     use alloc::{string::String, vec::Vec};
     use core::any::TypeId;
 
-    use crate as bevy_asset;
     use crate::{Asset, AssetApp, AssetPlugin, ReflectAsset, UntypedHandle};
     use bevy_app::App;
     use bevy_ecs::reflect::AppTypeRegistry;

crates/bevy_asset/src/server/loaders.rs

@@ -352,7 +352,7 @@ mod tests {
     use bevy_reflect::TypePath;
     use bevy_tasks::block_on;
 
-    use crate::{self as bevy_asset, Asset};
+    use crate::Asset;
 
     use super::*;
 

crates/bevy_ecs/src/bundle.rs

@@ -1710,7 +1710,6 @@ fn sorted_remove<T: Eq + Ord + Copy>(source: &mut Vec<T>, remove: &[T]) {
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{component::HookContext, prelude::*, world::DeferredWorld};
     use alloc::vec;
 

crates/bevy_ecs/src/change_detection.rs

@@ -1268,7 +1268,6 @@ mod tests {
     use core::panic::Location;
 
     use crate::{
-        self as bevy_ecs,
         change_detection::{
             Mut, NonSendMut, Ref, ResMut, TicksMut, CHECK_TICK_THRESHOLD, MAX_CHANGE_AGE,
         },

crates/bevy_ecs/src/component.rs

@@ -1,7 +1,6 @@
 //! Types for declaring and storing [`Component`]s.
 
 use crate::{
-    self as bevy_ecs,
     archetype::ArchetypeFlags,
     bundle::BundleInfo,
     change_detection::MAX_CHANGE_AGE,

crates/bevy_ecs/src/entity/clone_entities.rs

@@ -816,12 +816,11 @@ impl<'w> EntityClonerBuilder<'w> {
 mod tests {
     use super::ComponentCloneCtx;
     use crate::{
-        self as bevy_ecs,
         component::{Component, ComponentCloneBehavior, ComponentDescriptor, StorageType},
         entity::{hash_map::EntityHashMap, Entity, EntityCloner},
-        hierarchy::{ChildOf, Children},
+        prelude::{ChildOf, Children, Resource},
-        reflect::{AppTypeRegistry, ReflectComponent, ReflectFromWorld},
+        reflect::AppTypeRegistry,
-        resource::Resource,
+        reflect::{ReflectComponent, ReflectFromWorld},
         system::Commands,
         world::{FromWorld, World},
     };
@@ -835,6 +834,7 @@ mod tests {
     mod reflect {
         use super::*;
         use crate::{
+            component::{Component, ComponentCloneBehavior},
             entity::EntityCloner,
             reflect::{AppTypeRegistry, ReflectComponent, ReflectFromWorld},
             system::Commands,

crates/bevy_ecs/src/entity/entity_set.rs

@@ -470,7 +470,6 @@ mod tests {
     use crate::query::{QueryState, With};
     use crate::system::Query;
     use crate::world::Mut;
-    use crate::{self as bevy_ecs};
 
     use super::UniqueEntityIter;
 

crates/bevy_ecs/src/entity/visit_entities.rs

@@ -57,7 +57,6 @@ impl VisitEntitiesMut for Entity {
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         entity::{hash_map::EntityHashMap, MapEntities, SceneEntityMapper},
         world::World,
     };

crates/bevy_ecs/src/entity_disabling.rs

@@ -21,7 +21,6 @@
 //! [`World`]: crate::prelude::World
 //! [`Query` performance]: crate::prelude::Query#performance
 
-use crate as bevy_ecs;
 use crate::{
     component::{ComponentId, Components, StorageType},
     query::FilteredAccess,

crates/bevy_ecs/src/event/base.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 use crate::component::ComponentId;
 use crate::world::World;
 use crate::{component::Component, traversal::Traversal};

crates/bevy_ecs/src/event/collections.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 use alloc::vec::Vec;
 use bevy_ecs::{
     event::{Event, EventCursor, EventId, EventInstance},
@@ -398,7 +397,7 @@ impl<E: Event> ExactSizeIterator for SendBatchIds<E> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{self as bevy_ecs, event::Events};
+    use crate::event::Events;
     use bevy_ecs_macros::Event;
 
     #[test]

crates/bevy_ecs/src/event/event_cursor.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 use bevy_ecs::event::{
     Event, EventIterator, EventIteratorWithId, EventMutIterator, EventMutIteratorWithId, Events,
 };

crates/bevy_ecs/src/event/iterators.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 #[cfg(feature = "multi_threaded")]
 use bevy_ecs::batching::BatchingStrategy;
 use bevy_ecs::event::{Event, EventCursor, EventId, EventInstance, Events};

crates/bevy_ecs/src/event/mod.rs

@@ -31,7 +31,6 @@ pub use writer::EventWriter;
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use alloc::{vec, vec::Vec};
     use bevy_ecs::{event::*, system::assert_is_read_only_system};
     use bevy_ecs_macros::Event;

crates/bevy_ecs/src/event/mut_iterators.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 #[cfg(feature = "multi_threaded")]
 use bevy_ecs::batching::BatchingStrategy;
 use bevy_ecs::event::{Event, EventCursor, EventId, EventInstance, Events};

crates/bevy_ecs/src/event/mutator.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 #[cfg(feature = "multi_threaded")]
 use bevy_ecs::event::EventMutParIter;
 use bevy_ecs::{

crates/bevy_ecs/src/event/reader.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 #[cfg(feature = "multi_threaded")]
 use bevy_ecs::event::EventParIter;
 use bevy_ecs::{

crates/bevy_ecs/src/event/registry.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 use alloc::vec::Vec;
 use bevy_ecs::{
     change_detection::{DetectChangesMut, MutUntyped},

crates/bevy_ecs/src/event/update.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 use bevy_ecs::{
     change_detection::Mut,
     component::Tick,

crates/bevy_ecs/src/event/writer.rs

@@ -1,4 +1,3 @@
-use crate as bevy_ecs;
 use bevy_ecs::{
     event::{Event, EventId, Events, SendBatchIds},
     system::{ResMut, SystemParam},

crates/bevy_ecs/src/hierarchy.rs

@@ -9,7 +9,6 @@
 #[cfg(feature = "bevy_reflect")]
 use crate::reflect::{ReflectComponent, ReflectFromWorld};
 use crate::{
-    self as bevy_ecs,
     bundle::Bundle,
     component::{Component, HookContext},
     entity::Entity,

crates/bevy_ecs/src/identifier/mod.rs

@@ -201,7 +201,7 @@ mod tests {
         // and also Entity flag.
         let high = 0x7FFFFFFF;
         let low = 0xC;
-        let bits: u64 = high << u32::BITS | low;
+        let bits: u64 = (high << u32::BITS) | low;
 
         let id = Identifier::try_from_bits(bits).unwrap();
 

crates/bevy_ecs/src/lib.rs

@@ -33,6 +33,9 @@ compile_error!("bevy_ecs cannot safely compile for a 16-bit platform.");
 
 extern crate alloc;
 
+// Required to make proc macros work in bevy itself.
+extern crate self as bevy_ecs;
+
 pub mod archetype;
 pub mod batching;
 pub mod bundle;
@@ -128,7 +131,6 @@ pub mod __macro_exports {
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{
         bundle::Bundle,
         change_detection::Ref,

crates/bevy_ecs/src/name.rs

@@ -1,6 +1,6 @@
 //! Provides the [`Name`] [`Component`], used for identifying an [`Entity`].
 
-use crate::{self as bevy_ecs, component::Component, entity::Entity, query::QueryData};
+use crate::{component::Component, entity::Entity, query::QueryData};
 
 use alloc::{
     borrow::{Cow, ToOwned},

crates/bevy_ecs/src/observer/entity_observer.rs

@@ -110,8 +110,8 @@ fn component_clone_observed_by(commands: &mut Commands, ctx: &mut ComponentClone
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs, entity::EntityCloner, event::Event, observer::Trigger,
+        entity::EntityCloner, event::Event, observer::Trigger, resource::Resource, system::ResMut,
-        resource::Resource, system::ResMut, world::World,
+        world::World,
     };
 
     #[derive(Resource, Default)]

crates/bevy_ecs/src/observer/mod.rs

@@ -864,7 +864,6 @@ mod tests {
     use bevy_platform_support::collections::HashMap;
     use bevy_ptr::OwningPtr;
 
-    use crate as bevy_ecs;
     use crate::component::ComponentId;
     use crate::{
         observer::{Observer, ObserverDescriptor, ObserverState, OnReplace},

crates/bevy_ecs/src/query/builder.rs

@@ -275,7 +275,6 @@ impl<'w, D: QueryData, F: QueryFilter> QueryBuilder<'w, D, F> {
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{prelude::*, world::FilteredEntityRef};
     use std::dbg;
 

crates/bevy_ecs/src/query/error.rs

@@ -111,7 +111,6 @@ pub enum QuerySingleError {
 
 #[cfg(test)]
 mod test {
-    use crate as bevy_ecs;
     use crate::prelude::World;
     use alloc::format;
     use bevy_ecs_macros::Component;

crates/bevy_ecs/src/query/fetch.rs

@@ -2481,10 +2481,7 @@ mod tests {
     use bevy_ecs_macros::QueryData;
 
     use super::*;
-    use crate::{
+    use crate::system::{assert_is_system, Query};
-        self as bevy_ecs,
-        system::{assert_is_system, Query},
-    };
 
     #[derive(Component)]
     pub struct A;

crates/bevy_ecs/src/query/iter.rs

@@ -1309,7 +1309,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter, I: Iterator<Item: EntityBorrow>>
     ///     // We need to collect the internal iterator before iterating mutably
     ///     let mut parent_query_iter = query.iter_many_mut(entity_list)
     ///         .sort::<Entity>();
-    ///     
+    ///
     ///     let mut scratch_value = 0;
     ///     while let Some(mut part_value) = parent_query_iter.fetch_next_back()
     ///     {
@@ -2582,7 +2582,6 @@ mod tests {
     use crate::component::Component;
     use crate::entity::Entity;
     use crate::prelude::World;
-    use crate::{self as bevy_ecs};
 
     #[derive(Component, Debug, PartialEq, PartialOrd, Clone, Copy)]
     struct A(f32);

crates/bevy_ecs/src/query/mod.rs

@@ -104,7 +104,6 @@ impl<T> DebugCheckedUnwrap for Option<T> {
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         archetype::Archetype,
         component::{Component, ComponentId, Components, Tick},
         prelude::{AnyOf, Changed, Entity, Or, QueryState, Res, ResMut, Resource, With, Without},

crates/bevy_ecs/src/query/state.rs

@@ -2010,7 +2010,6 @@ impl<D: QueryData, F: QueryFilter> From<QueryBuilder<'_, D, F>> for QueryState<D
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{
         component::Component, entity_disabling::DefaultQueryFilters, prelude::*,
         query::QueryEntityError, world::FilteredEntityRef,

crates/bevy_ecs/src/reflect/entity_commands.rs

@@ -388,7 +388,6 @@ fn remove_reflect_with_registry_ref(
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         bundle::Bundle,
         component::Component,
         prelude::{AppTypeRegistry, ReflectComponent},

crates/bevy_ecs/src/reflect/mod.rs

@@ -5,7 +5,6 @@ use core::{
     ops::{Deref, DerefMut},
 };
 
-use crate as bevy_ecs;
 use crate::{resource::Resource, world::World};
 use bevy_reflect::{
     std_traits::ReflectDefault, PartialReflect, Reflect, ReflectFromReflect, TypePath,

crates/bevy_ecs/src/relationship/mod.rs

@@ -286,7 +286,6 @@ pub fn clone_relationship_target<T: RelationshipTarget>(
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::world::World;
     use crate::{component::Component, entity::Entity};
     use alloc::vec::Vec;

crates/bevy_ecs/src/relationship/related_methods.rs

@@ -249,7 +249,6 @@ impl<'w, R: Relationship> RelatedSpawnerCommands<'w, R> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_ecs;
     use crate::prelude::{ChildOf, Children, Component};
 
     #[derive(Component, Clone, Copy)]

crates/bevy_ecs/src/relationship/relationship_source_collection.rs

@@ -119,7 +119,6 @@ impl<const N: usize> RelationshipSourceCollection for SmallVec<[Entity; N]> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_ecs;
     use crate::prelude::{Component, World};
     use crate::relationship::RelationshipTarget;
 

crates/bevy_ecs/src/removal_detection.rs

@@ -1,7 +1,6 @@
 //! Alerting events when a component is removed from an entity.
 
 use crate::{
-    self as bevy_ecs,
     component::{Component, ComponentId, ComponentIdFor, Tick},
     entity::Entity,
     event::{Event, EventCursor, EventId, EventIterator, EventIteratorWithId, Events},

crates/bevy_ecs/src/schedule/condition.rs

@@ -1263,7 +1263,6 @@ where
 #[cfg(test)]
 mod tests {
     use super::{common_conditions::*, Condition};
-    use crate as bevy_ecs;
     use crate::query::With;
     use crate::{
         change_detection::ResMut,

crates/bevy_ecs/src/schedule/executor/mod.rs

@@ -311,7 +311,6 @@ mod __rust_begin_short_backtrace {
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         prelude::{IntoSystemConfigs, IntoSystemSetConfigs, Resource, Schedule, SystemSet},
         schedule::ExecutorKind,
         system::{Commands, Res, WithParamWarnPolicy},

crates/bevy_ecs/src/schedule/executor/multi_threaded.rs

@@ -22,8 +22,6 @@ use crate::{
     world::{unsafe_world_cell::UnsafeWorldCell, World},
 };
 
-use crate as bevy_ecs;
-
 use super::__rust_begin_short_backtrace;
 
 /// Borrowed data used by the [`MultiThreadedExecutor`].
@@ -796,7 +794,6 @@ impl MainThreadExecutor {
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         prelude::Resource,
         schedule::{ExecutorKind, IntoSystemConfigs, Schedule},
         system::Commands,

crates/bevy_ecs/src/schedule/mod.rs

@@ -29,7 +29,6 @@ mod tests {
     use alloc::{string::ToString, vec, vec::Vec};
     use core::sync::atomic::{AtomicU32, Ordering};
 
-    pub use crate as bevy_ecs;
     pub use crate::{
         prelude::World,
         resource::Resource,
@@ -730,8 +729,6 @@ mod tests {
         use alloc::collections::BTreeSet;
 
         use super::*;
-        // Required to make the derive macro behave
-        use crate as bevy_ecs;
         use crate::prelude::*;
 
         #[derive(Resource)]

crates/bevy_ecs/src/schedule/schedule.rs

@@ -25,7 +25,6 @@ use thiserror::Error;
 use tracing::info_span;
 
 use crate::{
-    self as bevy_ecs,
     component::{ComponentId, Components, Tick},
     prelude::Component,
     resource::Resource,
@@ -2020,7 +2019,6 @@ mod tests {
     use bevy_ecs_macros::ScheduleLabel;
 
     use crate::{
-        self as bevy_ecs,
         prelude::{Res, Resource},
         schedule::{
             tests::ResMut, IntoSystemConfigs, IntoSystemSetConfigs, Schedule,

crates/bevy_ecs/src/schedule/set.rs

@@ -225,7 +225,7 @@ mod tests {
 
     #[test]
     fn test_schedule_label() {
-        use crate::{self as bevy_ecs, world::World};
+        use crate::world::World;
 
         #[derive(Resource)]
         struct Flag(bool);
@@ -257,8 +257,6 @@ mod tests {
 
     #[test]
     fn test_derive_schedule_label() {
-        use crate::{self as bevy_ecs};
-
         #[derive(ScheduleLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
         struct UnitLabel;
 
@@ -359,8 +357,6 @@ mod tests {
 
     #[test]
     fn test_derive_system_set() {
-        use crate::{self as bevy_ecs};
-
         #[derive(SystemSet, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
         struct UnitSet;
 

crates/bevy_ecs/src/schedule/stepping.rs

@@ -17,8 +17,6 @@ use log::error;
 #[cfg(test)]
 use log::debug;
 
-use crate as bevy_ecs;
-
 #[derive(Debug, Default, PartialEq, Eq, Copy, Clone)]
 enum Action {
     /// Stepping is disabled; run all systems
@@ -831,8 +829,6 @@ mod tests {
     use alloc::{format, vec};
     use std::println;
 
-    pub use crate as bevy_ecs;
-
     #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
     struct TestSchedule;
 

crates/bevy_ecs/src/storage/blob_array.rs

@@ -479,7 +479,6 @@ impl BlobArray {
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use bevy_ecs::prelude::*;
 
     #[derive(Component)]

crates/bevy_ecs/src/storage/blob_vec.rs

@@ -498,7 +498,6 @@ const fn padding_needed_for(layout: &Layout, align: usize) -> usize {
 #[cfg(test)]
 mod tests {
     use super::BlobVec;
-    use crate as bevy_ecs; // required for derive macros
     use crate::{component::Component, ptr::OwningPtr, world::World};
     use alloc::{
         rc::Rc,

crates/bevy_ecs/src/storage/sparse_set.rs

@@ -661,7 +661,6 @@ impl SparseSets {
 mod tests {
     use super::SparseSets;
     use crate::{
-        self as bevy_ecs,
         component::{Component, ComponentDescriptor, ComponentId, ComponentInfo},
         entity::Entity,
         storage::SparseSet,

crates/bevy_ecs/src/storage/table/mod.rs

@@ -815,7 +815,6 @@ impl Drop for Table {
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{
         component::{Component, Components, Tick},
         entity::Entity,

crates/bevy_ecs/src/system/builder.rs

@@ -712,7 +712,6 @@ unsafe impl<'w, 's, T: FnOnce(&mut FilteredResourcesMutBuilder)>
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{
         entity::Entities,
         prelude::{Component, Query},

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

@@ -17,7 +17,6 @@ use core::panic::Location;
 use log::error;
 
 use crate::{
-    self as bevy_ecs,
     bundle::{Bundle, InsertMode},
     change_detection::Mut,
     component::{Component, ComponentId, Mutable},
@@ -2203,7 +2202,6 @@ impl<'a, T: Component> EntityEntryCommands<'a, T> {
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         component::{require, Component},
         resource::Resource,
         system::Commands,

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

@@ -1,7 +1,6 @@
 use bevy_utils::Parallel;
 
 use crate::{
-    self as bevy_ecs,
     entity::Entities,
     prelude::World,
     system::{Deferred, SystemBuffer, SystemMeta, SystemParam},

crates/bevy_ecs/src/system/exclusive_system_param.rs

@@ -136,7 +136,6 @@ all_tuples!(
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_ecs;
     use crate::{schedule::Schedule, system::Local, world::World};
     use alloc::vec::Vec;
     use bevy_ecs_macros::Resource;

crates/bevy_ecs/src/system/mod.rs

@@ -330,7 +330,6 @@ mod tests {
     use std::println;
 
     use crate::{
-        self as bevy_ecs,
         archetype::{ArchetypeComponentId, Archetypes},
         bundle::Bundles,
         change_detection::DetectChanges,

crates/bevy_ecs/src/system/observer_system.rs

@@ -60,7 +60,6 @@ where
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_ecs,
         event::Event,
         observer::Trigger,
         system::{In, IntoSystem},

crates/bevy_ecs/src/system/system.rs

@@ -381,7 +381,6 @@ impl Debug for RunSystemError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_ecs;
     use crate::prelude::*;
 
     #[test]

crates/bevy_ecs/src/system/system_param.rs

@@ -2582,10 +2582,7 @@ unsafe impl SystemParam for FilteredResourcesMut<'_, '_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
+    use crate::system::assert_is_system;
-        self as bevy_ecs, // Necessary for the `SystemParam` Derive when used inside `bevy_ecs`.
-        system::assert_is_system,
-    };
     use core::cell::RefCell;
 
     // Compile test for https://github.com/bevyengine/bevy/pull/2838.

crates/bevy_ecs/src/system/system_registry.rs

@@ -1,7 +1,6 @@
 #[cfg(feature = "bevy_reflect")]
 use crate::reflect::ReflectComponent;
 use crate::{
-    self as bevy_ecs,
     change_detection::Mut,
     entity::Entity,
     system::{input::SystemInput, BoxedSystem, IntoSystem, System},
@@ -498,7 +497,6 @@ impl<I: SystemInput, O> core::fmt::Debug for RegisteredSystemError<I, O> {
 
 mod tests {
     use crate::prelude::*;
-    use crate::{self as bevy_ecs};
 
     #[derive(Resource, Default, PartialEq, Debug)]
     struct Counter(u8);

crates/bevy_ecs/src/world/command_queue.rs

@@ -335,7 +335,7 @@ impl SystemBuffer for CommandQueue {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{self as bevy_ecs, resource::Resource};
+    use crate::resource::Resource;
     use alloc::{borrow::ToOwned, string::String, sync::Arc};
     use core::{
         panic::AssertUnwindSafe,

crates/bevy_ecs/src/world/component_constants.rs

@@ -1,7 +1,6 @@
 //! Internal components used by bevy with a fixed component id.
 //! Constants are used to skip [`TypeId`] lookups in hot paths.
 use super::*;
-use crate::{self as bevy_ecs};
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
 

crates/bevy_ecs/src/world/entity_ref.rs

@@ -4417,7 +4417,6 @@ mod tests {
 
     use crate::component::HookContext;
     use crate::{
-        self as bevy_ecs,
         change_detection::MutUntyped,
         component::ComponentId,
         prelude::*,

crates/bevy_ecs/src/world/mod.rs

@@ -3763,9 +3763,6 @@ mod tests {
     };
     use std::{println, sync::Mutex};
 
-    // For bevy_ecs_macros
-    use crate as bevy_ecs;
-
     type ID = u8;
 
     #[derive(Clone, Copy, Debug, PartialEq, Eq)]

crates/bevy_ecs/src/world/reflect.rs

@@ -251,11 +251,7 @@ mod tests {
 
     use bevy_reflect::Reflect;
 
-    use crate::{
+    use crate::prelude::{AppTypeRegistry, Component, DetectChanges, World};
-        // For bevy_ecs_macros
-        self as bevy_ecs,
-        prelude::{AppTypeRegistry, Component, DetectChanges, World},
-    };
 
     #[derive(Component, Reflect)]
     struct RFoo(i32);

crates/bevy_ecs/src/world/unsafe_world_cell.rs

@@ -1222,7 +1222,6 @@ impl EntityBorrow for UnsafeEntityCell<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_ecs;
 
     #[test]
     #[should_panic = "is forbidden"]

crates/bevy_encase_derive/src/lib.rs

@@ -31,7 +31,7 @@ fn bevy_encase_path() -> syn::Path {
                 segments,
             }
         })
-        .unwrap_or_else(|| bevy_manifest.get_path(ENCASE))
+        .unwrap_or_else(|_err| bevy_manifest.get_path(ENCASE))
 }
 
 implement!(bevy_encase_path());

crates/bevy_gizmos/src/aabb.rs

@@ -1,7 +1,5 @@
 //! A module adding debug visualization of [`Aabb`]s.
 
-use crate as bevy_gizmos;
-
 use bevy_app::{Plugin, PostUpdate};
 use bevy_color::{Color, Oklcha};
 use bevy_ecs::{

crates/bevy_gizmos/src/config.rs

@@ -1,6 +1,5 @@
 //! A module for the [`GizmoConfig<T>`] [`Resource`].
 
-use crate::{self as bevy_gizmos};
 pub use bevy_gizmos_macros::GizmoConfigGroup;
 
 #[cfg(all(

crates/bevy_gizmos/src/lib.rs

@@ -19,6 +19,9 @@
 //!
 //! See the documentation on [Gizmos](crate::gizmos::Gizmos) for more examples.
 
+// Required to make proc macros work in bevy itself.
+extern crate self as bevy_gizmos;
+
 /// System set label for the systems handling the rendering of gizmos.
 #[derive(SystemSet, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum GizmoRenderSystem {

crates/bevy_gizmos/src/light.rs

@@ -2,7 +2,7 @@
 
 use core::f32::consts::PI;
 
-use crate::{self as bevy_gizmos, primitives::dim3::GizmoPrimitive3d};
+use crate::primitives::dim3::GizmoPrimitive3d;
 
 use bevy_app::{Plugin, PostUpdate};
 use bevy_color::{

crates/bevy_macro_utils/Cargo.toml

@@ -9,12 +9,10 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [dependencies]
-toml_edit = { version = "0.22.7", default-features = false, features = [
-  "parse",
-] }
 syn = "2.0"
 quote = "1.0"
 proc-macro2 = "1.0"
+cargo-manifest-proc-macros = "0.3.3"
 
 [lints]
 workspace = true

crates/bevy_macro_utils/src/bevy_manifest.rs

@@ -1,83 +1,55 @@
 extern crate proc_macro;
 
-use proc_macro::TokenStream;
+use std::sync::MutexGuard;
-use std::{env, path::PathBuf, sync::LazyLock};
-use toml_edit::{DocumentMut, Item};
 
-/// The path to the `Cargo.toml` file for the Bevy project.
+use cargo_manifest_proc_macros::{
-pub struct BevyManifest {
+    CargoManifest, CrateReExportingPolicy, KnownReExportingCrate, PathPiece,
-    manifest: DocumentMut,
+    TryResolveCratePathError,
+};
+use proc_macro::TokenStream;
+
+struct BevyReExportingPolicy;
+
+impl CrateReExportingPolicy for BevyReExportingPolicy {
+    fn get_re_exported_crate_path(&self, crate_name: &str) -> Option<PathPiece> {
+        crate_name.strip_prefix("bevy_").map(|s| {
+            let mut path = PathPiece::new();
+            path.push(syn::parse_str::<syn::PathSegment>(s).unwrap());
+            path
+        })
+    }
 }
 
 const BEVY: &str = "bevy";
-const BEVY_INTERNAL: &str = "bevy_internal";
+
+const KNOWN_RE_EXPORTING_CRATE_BEVY: KnownReExportingCrate = KnownReExportingCrate {
+    re_exporting_crate_package_name: BEVY,
+    crate_re_exporting_policy: &BevyReExportingPolicy {},
+};
+
+const ALL_KNOWN_RE_EXPORTING_CRATES: &[&KnownReExportingCrate] = &[&KNOWN_RE_EXPORTING_CRATE_BEVY];
+
+/// The path to the `Cargo.toml` file for the Bevy project.
+pub struct BevyManifest(MutexGuard<'static, CargoManifest>);
 
 impl BevyManifest {
     /// Returns a global shared instance of the [`BevyManifest`] struct.
-    pub fn shared() -> &'static LazyLock<Self> {
+    pub fn shared() -> Self {
-        static LAZY_SELF: LazyLock<BevyManifest> = LazyLock::new(|| BevyManifest {
+        Self(CargoManifest::shared())
-            manifest: env::var_os("CARGO_MANIFEST_DIR")
-                .map(PathBuf::from)
-                .map(|mut path| {
-                    path.push("Cargo.toml");
-                    if !path.exists() {
-                        panic!(
-                            "No Cargo manifest found for crate. Expected: {}",
-                            path.display()
-                        );
-                    }
-                    let manifest = std::fs::read_to_string(path.clone()).unwrap_or_else(|_| {
-                        panic!("Unable to read cargo manifest: {}", path.display())
-                    });
-                    manifest.parse::<DocumentMut>().unwrap_or_else(|_| {
-                        panic!("Failed to parse cargo manifest: {}", path.display())
-                    })
-                })
-                .expect("CARGO_MANIFEST_DIR is not defined."),
-        });
-        &LAZY_SELF
     }
 
     /// Attempt to retrieve the [path](syn::Path) of a particular package in
     /// the [manifest](BevyManifest) by [name](str).
-    pub fn maybe_get_path(&self, name: &str) -> Option<syn::Path> {
+    pub fn maybe_get_path(&self, name: &str) -> Result<syn::Path, TryResolveCratePathError> {
-        fn dep_package(dep: &Item) -> Option<&str> {
+        self.0
-            if dep.as_str().is_some() {
+            .try_resolve_crate_path(name, ALL_KNOWN_RE_EXPORTING_CRATES)
-                None
-            } else {
-                dep.get("package").map(|name| name.as_str().unwrap())
-            }
-        }
-
-        let find_in_deps = |deps: &Item| -> Option<syn::Path> {
-            let package = if let Some(dep) = deps.get(name) {
-                return Some(Self::parse_str(dep_package(dep).unwrap_or(name)));
-            } else if let Some(dep) = deps.get(BEVY) {
-                dep_package(dep).unwrap_or(BEVY)
-            } else if let Some(dep) = deps.get(BEVY_INTERNAL) {
-                dep_package(dep).unwrap_or(BEVY_INTERNAL)
-            } else {
-                return None;
-            };
-
-            let mut path = Self::parse_str::<syn::Path>(package);
-            if let Some(module) = name.strip_prefix("bevy_") {
-                path.segments.push(Self::parse_str(module));
-            }
-            Some(path)
-        };
-
-        let deps = self.manifest.get("dependencies");
-        let deps_dev = self.manifest.get("dev-dependencies");
-
-        deps.and_then(find_in_deps)
-            .or_else(|| deps_dev.and_then(find_in_deps))
     }
 
     /// Returns the path for the crate with the given name.
     pub fn get_path(&self, name: &str) -> syn::Path {
         self.maybe_get_path(name)
-            .unwrap_or_else(|| Self::parse_str(name))
+            //.expect("Failed to get path for crate")
+            .unwrap_or_else(|_err| Self::parse_str(name))
     }
 
     /// Attempt to parse the provided [path](str) as a [syntax tree node](syn::parse::Parse)
@@ -97,7 +69,7 @@ impl BevyManifest {
     }
 
     /// Attempt to get a subcrate [path](syn::Path) under Bevy by [name](str)
-    pub fn get_subcrate(&self, subcrate: &str) -> Option<syn::Path> {
+    pub fn get_subcrate(&self, subcrate: &str) -> Result<syn::Path, TryResolveCratePathError> {
         self.maybe_get_path(BEVY)
             .map(|bevy_path| {
                 let mut segments = bevy_path.segments;
@@ -107,6 +79,6 @@ impl BevyManifest {
                     segments,
                 }
             })
-            .or_else(|| self.maybe_get_path(&format!("bevy_{subcrate}")))
+            .or_else(|_err| self.maybe_get_path(&format!("bevy_{subcrate}")))
     }
 }

crates/bevy_reflect/derive/src/trait_reflection.rs

@@ -1,7 +1,4 @@
-use bevy_macro_utils::{
+use bevy_macro_utils::fq_std::{FQClone, FQOption, FQResult};
-    fq_std::{FQClone, FQOption, FQResult},
-    BevyManifest,
-};
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse::Parse, parse_macro_input, Attribute, ItemTrait, Token};
@@ -34,7 +31,7 @@ pub(crate) fn reflect_trait(_args: &TokenStream, input: TokenStream) -> TokenStr
     let trait_ident = &item_trait.ident;
     let trait_vis = &item_trait.vis;
     let reflect_trait_ident = crate::ident::get_reflect_ident(&item_trait.ident.to_string());
-    let bevy_reflect_path = BevyManifest::shared().get_path("bevy_reflect");
+    let bevy_reflect_path = crate::meta::get_bevy_reflect_path();
 
     let struct_doc = format!(
         " A type generated by the #[reflect_trait] macro for the `{trait_ident}` trait.\n\n This allows casting from `dyn Reflect` to `dyn {trait_ident}`.",

crates/bevy_reflect/src/array.rs

@@ -1,8 +1,8 @@
 use crate::generics::impl_generic_info_methods;
 use crate::{
-    self as bevy_reflect, type_info::impl_type_methods, utility::reflect_hasher, ApplyError,
+    type_info::impl_type_methods, utility::reflect_hasher, ApplyError, Generics, MaybeTyped,
-    Generics, MaybeTyped, PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned,
+    PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, Type, TypeInfo,
-    ReflectRef, Type, TypeInfo, TypePath,
+    TypePath,
 };
 use alloc::{boxed::Box, vec::Vec};
 use bevy_reflect_derive::impl_type_path;

crates/bevy_reflect/src/attributes.rs

@@ -178,7 +178,6 @@ pub(crate) use impl_custom_attribute_methods;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_reflect;
     use crate::{type_info::Typed, TypeInfo, VariantInfo};
     use alloc::{format, string::String};
     use core::ops::RangeInclusive;

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -1,9 +1,9 @@
 use bevy_reflect_derive::impl_type_path;
 
 use crate::{
-    self as bevy_reflect, enum_debug, enum_hash, enum_partial_eq, ApplyError, DynamicStruct,
+    enum_debug, enum_hash, enum_partial_eq, ApplyError, DynamicStruct, DynamicTuple, Enum,
-    DynamicTuple, Enum, PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef,
+    PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, Struct, Tuple,
-    Struct, Tuple, TypeInfo, VariantFieldIter, VariantType,
+    TypeInfo, VariantFieldIter, VariantType,
 };
 
 use alloc::{boxed::Box, string::String};

crates/bevy_reflect/src/enums/enum_trait.rs

@@ -317,7 +317,6 @@ impl<'a> VariantField<'a> {
 // Tests that need access to internal fields have to go here rather than in mod.rs
 #[cfg(test)]
 mod tests {
-    use crate as bevy_reflect;
     use crate::*;
 
     #[derive(Reflect, Debug, PartialEq)]

crates/bevy_reflect/src/enums/mod.rs

@@ -10,7 +10,6 @@ pub use variants::*;
 
 #[cfg(test)]
 mod tests {
-    use crate as bevy_reflect;
     use crate::*;
     use alloc::boxed::Box;
 

crates/bevy_reflect/src/enums/variants.rs

@@ -359,7 +359,6 @@ impl UnitVariantInfo {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_reflect;
     use crate::{Reflect, Typed};
 
     #[test]

crates/bevy_reflect/src/func/dynamic_function.rs

@@ -1,5 +1,4 @@
 use crate::{
-    self as bevy_reflect,
     __macro_exports::RegisterForReflection,
     func::{
         args::{ArgCount, ArgList},

crates/bevy_reflect/src/generics.rs

@@ -252,7 +252,6 @@ pub(crate) use impl_generic_info_methods;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate as bevy_reflect;
     use crate::{Reflect, Typed};
     use alloc::string::String;
     use core::fmt::Debug;

crates/bevy_reflect/src/impls/foldhash.rs

@@ -1,4 +1,4 @@
-use crate::{self as bevy_reflect, impl_type_path};
+use crate::impl_type_path;
 
 impl_type_path!(::foldhash::fast::FoldHasher);
 impl_type_path!(::foldhash::fast::FixedState);

crates/bevy_reflect/src/impls/glam.rs

@@ -1,4 +1,3 @@
-use crate as bevy_reflect;
 use crate::{std_traits::ReflectDefault, ReflectDeserialize, ReflectSerialize};
 use assert_type_match::assert_type_match;
 use bevy_reflect_derive::{impl_reflect, impl_reflect_opaque};

crates/bevy_reflect/src/impls/petgraph.rs

@@ -1,7 +1,4 @@
-use crate::{
+use crate::{impl_reflect_opaque, prelude::ReflectDefault, ReflectDeserialize, ReflectSerialize};
-    self as bevy_reflect, impl_reflect_opaque, prelude::ReflectDefault, ReflectDeserialize,
-    ReflectSerialize,
-};
 
 impl_reflect_opaque!(::petgraph::graph::NodeIndex(
     Default,

crates/bevy_reflect/src/impls/smallvec.rs

@@ -4,10 +4,10 @@ use core::any::Any;
 use smallvec::{Array as SmallArray, SmallVec};
 
 use crate::{
-    self as bevy_reflect, utility::GenericTypeInfoCell, ApplyError, FromReflect, FromType,
+    utility::GenericTypeInfoCell, ApplyError, FromReflect, FromType, Generics, GetTypeRegistration,
-    Generics, GetTypeRegistration, List, ListInfo, ListIter, MaybeTyped, PartialReflect, Reflect,
+    List, ListInfo, ListIter, MaybeTyped, PartialReflect, Reflect, ReflectFromPtr, ReflectKind,
-    ReflectFromPtr, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypeParamInfo,
+    ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypeParamInfo, TypePath, TypeRegistration,
-    TypePath, TypeRegistration, Typed,
+    Typed,
 };
 
 impl<T: SmallArray + TypePath + Send + Sync> List for SmallVec<T>

crates/bevy_reflect/src/impls/smol_str.rs

@@ -1,6 +1,4 @@
-use crate::{
+use crate::{std_traits::ReflectDefault, ReflectDeserialize, ReflectSerialize};
-    self as bevy_reflect, std_traits::ReflectDefault, ReflectDeserialize, ReflectSerialize,
-};
 use bevy_reflect_derive::impl_reflect_opaque;
 
 impl_reflect_opaque!(::smol_str::SmolStr(

crates/bevy_reflect/src/impls/std.rs

@@ -4,7 +4,7 @@
 )]
 
 use crate::{
-    self as bevy_reflect, impl_type_path, map_apply, map_partial_eq, map_try_apply,
+    impl_type_path, map_apply, map_partial_eq, map_try_apply,
     prelude::ReflectDefault,
     reflect::impl_full_reflect,
     set_apply, set_partial_eq, set_try_apply,
@@ -2441,8 +2441,8 @@ crate::func::macros::impl_function_traits!(&'static Location<'static>);
 #[cfg(test)]
 mod tests {
     use crate::{
-        self as bevy_reflect, Enum, FromReflect, PartialReflect, Reflect, ReflectSerialize,
+        Enum, FromReflect, PartialReflect, Reflect, ReflectSerialize, TypeInfo, TypeRegistry,
-        TypeInfo, TypeRegistry, Typed, VariantInfo, VariantType,
+        Typed, VariantInfo, VariantType,
     };
     use alloc::{collections::BTreeMap, string::String, vec};
     use bevy_platform_support::collections::HashMap;

crates/bevy_reflect/src/impls/uuid.rs

@@ -1,5 +1,3 @@
-use crate as bevy_reflect;
-
 use crate::{std_traits::ReflectDefault, ReflectDeserialize, ReflectSerialize};
 use bevy_reflect_derive::impl_reflect_opaque;