Add core and alloc over std Lints (#15281)

# Objective - Fixes #6370 - Closes #6581 ## Solution - Added the following lints to the workspace: - `std_instead_of_core` - `std_instead_of_alloc` - `alloc_instead_of_core` - Used `cargo +nightly fmt` with [item level use formatting](https://rust-lang.github.io/rustfmt/?version=v1.6.0&search=#Item%5C%3A) to split all `use` statements into single items. - Used `cargo clippy --workspace --all-targets --all-features --fix --allow-dirty` to _attempt_ to resolve the new linting issues, and intervened where the lint was unable to resolve the issue automatically (usually due to needing an `extern crate alloc;` statement in a crate root). - Manually removed certain uses of `std` where negative feature gating prevented `--all-features` from finding the offending uses. - Used `cargo +nightly fmt` with [crate level use formatting](https://rust-lang.github.io/rustfmt/?version=v1.6.0&search=#Crate%5C%3A) to re-merge all `use` statements matching Bevy's previous styling. - Manually fixed cases where the `fmt` tool could not re-merge `use` statements due to conditional compilation attributes. ## Testing - Ran CI locally ## Migration Guide The MSRV is now 1.81. Please update to this version or higher. ## Notes - This is a _massive_ change to try and push through, which is why I've outlined the semi-automatic steps I used to create this PR, in case this fails and someone else tries again in the future. - Making this change has no impact on user code, but does mean Bevy contributors will be warned to use `core` and `alloc` instead of `std` where possible. - This lint is a critical first step towards investigating `no_std` options for Bevy. --------- Co-authored-by: François Mockers <francois.mockers@vleue.com>
bevyengine · Sep 27, 2024 · d70595b · d70595b
1 parent 4e78013
commit d70595b
Show file tree

Hide file tree

Showing 456 changed files with 1,718 additions and 1,659 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -48,15 +48,55 @@ ref_as_ptr = "warn"
 # see: https://github.com/bevyengine/bevy/pull/15375#issuecomment-2366966219
 too_long_first_doc_paragraph = "allow"
 
+std_instead_of_core = "warn"
+std_instead_of_alloc = "warn"
+alloc_instead_of_core = "warn"
+
 [workspace.lints.rust]
 missing_docs = "warn"
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(docsrs_dep)'] }
 unsafe_code = "deny"
 unsafe_op_in_unsafe_fn = "warn"
 unused_qualifications = "warn"
 
-[lints]
-workspace = true
+# Unfortunately, cargo does not currently support overriding workspace lints
+# inside a particular crate. See https://github.com/rust-lang/cargo/issues/13157
+#
+# We require an override for cases like `std_instead_of_core`, which are intended
+# for the library contributors and not for how users should consume Bevy.
+# To ensure examples aren't subject to these lints, below is a duplication of the
+# workspace lints, with the "overrides" applied.
+#
+# [lints]
+# workspace = true
+
+[lints.clippy]
+doc_markdown = "warn"
+manual_let_else = "warn"
+match_same_arms = "warn"
+redundant_closure_for_method_calls = "warn"
+redundant_else = "warn"
+semicolon_if_nothing_returned = "warn"
+type_complexity = "allow"
+undocumented_unsafe_blocks = "warn"
+unwrap_or_default = "warn"
+
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+ref_as_ptr = "warn"
+
+too_long_first_doc_paragraph = "allow"
+
+std_instead_of_core = "allow"
+std_instead_of_alloc = "allow"
+alloc_instead_of_core = "allow"
+
+[lints.rust]
+missing_docs = "warn"
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(docsrs_dep)'] }
+unsafe_code = "deny"
+unsafe_op_in_unsafe_fn = "warn"
+unused_qualifications = "warn"
 
 [features]
 default = [

diff --git a/benches/benches/bevy_ecs/change_detection.rs b/benches/benches/bevy_ecs/change_detection.rs
@@ -86,7 +86,7 @@ fn generic_bench<P: Copy>(
 
 fn all_added_detection_generic<T: Component + Default>(group: &mut BenchGroup, entity_count: u32) {
  group.bench_function(
- format!("{}_entities_{}", entity_count, std::any::type_name::<T>()),
+ format!("{}_entities_{}", entity_count, core::any::type_name::<T>()),
  |bencher| {
  bencher.iter_batched_ref(
  || {
@@ -110,8 +110,8 @@ fn all_added_detection_generic<T: Component + Default>(group: &mut BenchGroup, e
 
 fn all_added_detection(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("all_added_detection");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for &entity_count in ENTITIES_TO_BENCH_COUNT {
  generic_bench(
  &mut group,
@@ -129,7 +129,7 @@ fn all_changed_detection_generic<T: Component + Default + BenchModify>(
  entity_count: u32,
 ) {
  group.bench_function(
- format!("{}_entities_{}", entity_count, std::any::type_name::<T>()),
+ format!("{}_entities_{}", entity_count, core::any::type_name::<T>()),
  |bencher| {
  bencher.iter_batched_ref(
  || {
@@ -158,8 +158,8 @@ fn all_changed_detection_generic<T: Component + Default + BenchModify>(
 
 fn all_changed_detection(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("all_changed_detection");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for &entity_count in ENTITIES_TO_BENCH_COUNT {
  generic_bench(
  &mut group,
@@ -179,7 +179,7 @@ fn few_changed_detection_generic<T: Component + Default + BenchModify>(
  let ratio_to_modify = 0.1;
  let amount_to_modify = (entity_count as f32 * ratio_to_modify) as usize;
  group.bench_function(
- format!("{}_entities_{}", entity_count, std::any::type_name::<T>()),
+ format!("{}_entities_{}", entity_count, core::any::type_name::<T>()),
  |bencher| {
  bencher.iter_batched_ref(
  || {
@@ -208,8 +208,8 @@ fn few_changed_detection_generic<T: Component + Default + BenchModify>(
 
 fn few_changed_detection(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("few_changed_detection");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for &entity_count in ENTITIES_TO_BENCH_COUNT {
  generic_bench(
  &mut group,
@@ -227,7 +227,7 @@ fn none_changed_detection_generic<T: Component + Default>(
  entity_count: u32,
 ) {
  group.bench_function(
- format!("{}_entities_{}", entity_count, std::any::type_name::<T>()),
+ format!("{}_entities_{}", entity_count, core::any::type_name::<T>()),
  |bencher| {
  bencher.iter_batched_ref(
  || {
@@ -252,8 +252,8 @@ fn none_changed_detection_generic<T: Component + Default>(
 
 fn none_changed_detection(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("none_changed_detection");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for &entity_count in ENTITIES_TO_BENCH_COUNT {
  generic_bench(
  &mut group,
@@ -308,7 +308,7 @@ fn multiple_archetype_none_changed_detection_generic<T: Component + Default + Be
  "{}_archetypes_{}_entities_{}",
  archetype_count,
  entity_count,
- std::any::type_name::<T>()
+ core::any::type_name::<T>()
  ),
  |bencher| {
  bencher.iter_batched_ref(
@@ -356,8 +356,8 @@ fn multiple_archetype_none_changed_detection_generic<T: Component + Default + Be
 
 fn multiple_archetype_none_changed_detection(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("multiple_archetypes_none_changed_detection");
- group.warm_up_time(std::time::Duration::from_millis(800));
- group.measurement_time(std::time::Duration::from_secs(8));
+ group.warm_up_time(core::time::Duration::from_millis(800));
+ group.measurement_time(core::time::Duration::from_secs(8));
  for archetype_count in [5, 20, 100] {
  for entity_count in [10, 100, 1000, 10000] {
  multiple_archetype_none_changed_detection_generic::<Table>(

diff --git a/benches/benches/bevy_ecs/components/mod.rs b/benches/benches/bevy_ecs/components/mod.rs
@@ -23,8 +23,8 @@ criterion_group!(
 
 fn add_remove(c: &mut Criterion) {
  let mut group = c.benchmark_group("add_remove");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("table", |b| {
  let mut bench = add_remove_table::Benchmark::new();
  b.iter(move || bench.run());
@@ -38,8 +38,8 @@ fn add_remove(c: &mut Criterion) {
 
 fn add_remove_big(c: &mut Criterion) {
  let mut group = c.benchmark_group("add_remove_big");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("table", |b| {
  let mut bench = add_remove_big_table::Benchmark::new();
  b.iter(move || bench.run());
@@ -53,8 +53,8 @@ fn add_remove_big(c: &mut Criterion) {
 
 fn add_remove_very_big(c: &mut Criterion) {
  let mut group = c.benchmark_group("add_remove_very_big");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("table", |b| {
  let mut bench = add_remove_very_big_table::Benchmark::new();
  b.iter(move || bench.run());
@@ -64,8 +64,8 @@ fn add_remove_very_big(c: &mut Criterion) {
 
 fn insert_simple(c: &mut Criterion) {
  let mut group = c.benchmark_group("insert_simple");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("base", |b| {
  let mut bench = insert_simple::Benchmark::new();
  b.iter(move || bench.run());

diff --git a/benches/benches/bevy_ecs/events/iter.rs b/benches/benches/bevy_ecs/events/iter.rs
@@ -19,7 +19,7 @@ impl<const SIZE: usize> Benchmark<SIZE> {
  pub fn run(&mut self) {
  let mut reader = self.0.get_cursor();
  for evt in reader.read(&self.0) {
- std::hint::black_box(evt);
+ core::hint::black_box(evt);
  }
  }
 }
diff --git a/benches/benches/bevy_ecs/events/mod.rs b/benches/benches/bevy_ecs/events/mod.rs
@@ -7,8 +7,8 @@ criterion_group!(event_benches, send, iter);
 
 fn send(c: &mut Criterion) {
  let mut group = c.benchmark_group("events_send");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for count in [100, 1000, 10000, 50000] {
  group.bench_function(format!("size_4_events_{}", count), |b| {
  let mut bench = send::Benchmark::<4>::new(count);
@@ -32,8 +32,8 @@ fn send(c: &mut Criterion) {
 
 fn iter(c: &mut Criterion) {
  let mut group = c.benchmark_group("events_iter");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for count in [100, 1000, 10000, 50000] {
  group.bench_function(format!("size_4_events_{}", count), |b| {
  let mut bench = iter::Benchmark::<4>::new(count);

diff --git a/benches/benches/bevy_ecs/events/send.rs b/benches/benches/bevy_ecs/events/send.rs
@@ -32,7 +32,7 @@ impl<const SIZE: usize> Benchmark<SIZE> {
  pub fn run(&mut self) {
  for _ in 0..self.count {
  self.events
- .send(std::hint::black_box(BenchEvent([0u8; SIZE])));
+ .send(core::hint::black_box(BenchEvent([0u8; SIZE])));
  }
  self.events.update();
  }

diff --git a/benches/benches/bevy_ecs/fragmentation/mod.rs b/benches/benches/bevy_ecs/fragmentation/mod.rs
@@ -2,7 +2,7 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::SystemState;
 use criterion::*;
 use glam::*;
-use std::hint::black_box;
+use core::hint::black_box;
 
 criterion_group!(fragmentation_benches, iter_frag_empty);
 
@@ -17,8 +17,8 @@ fn flip_coin() -> bool {
 }
 fn iter_frag_empty(c: &mut Criterion) {
  let mut group = c.benchmark_group("iter_fragmented(4096)_empty");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
 
  group.bench_function("foreach_table", |b| {
  let mut world = World::new();

diff --git a/benches/benches/bevy_ecs/iteration/heavy_compute.rs b/benches/benches/bevy_ecs/iteration/heavy_compute.rs
@@ -17,8 +17,8 @@ pub fn heavy_compute(c: &mut Criterion) {
  struct Transform(Mat4);
 
  let mut group = c.benchmark_group("heavy_compute");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("base", |b| {
  ComputeTaskPool::get_or_init(TaskPool::default);
 

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple.rs b/benches/benches/bevy_ecs/iteration/iter_simple.rs
@@ -20,7 +20,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Position(Vec3::X),
  Rotation(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_foreach.rs b/benches/benches/bevy_ecs/iteration/iter_simple_foreach.rs
@@ -20,7 +20,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Position(Vec3::X),
  Rotation(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_foreach_sparse_set.rs b/benches/benches/bevy_ecs/iteration/iter_simple_foreach_sparse_set.rs
@@ -22,7 +22,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Position(Vec3::X),
  Rotation(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_foreach_wide.rs b/benches/benches/bevy_ecs/iteration/iter_simple_foreach_wide.rs
@@ -34,7 +34,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Rotation(Vec3::X),
  Position::<0>(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_foreach_wide_sparse_set.rs b/benches/benches/bevy_ecs/iteration/iter_simple_foreach_wide_sparse_set.rs
@@ -36,7 +36,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Rotation(Vec3::X),
  Position::<0>(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_sparse_set.rs b/benches/benches/bevy_ecs/iteration/iter_simple_sparse_set.rs
@@ -22,7 +22,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Position(Vec3::X),
  Rotation(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_system.rs b/benches/benches/bevy_ecs/iteration/iter_simple_system.rs
@@ -20,7 +20,7 @@ impl Benchmark {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Position(Vec3::X),
  Rotation(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_wide.rs b/benches/benches/bevy_ecs/iteration/iter_simple_wide.rs
@@ -34,7 +34,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Rotation(Vec3::X),
  Position::<0>(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/iter_simple_wide_sparse_set.rs b/benches/benches/bevy_ecs/iteration/iter_simple_wide_sparse_set.rs
@@ -36,7 +36,7 @@ impl<'w> Benchmark<'w> {
  let mut world = World::new();
 
  world.spawn_batch(
- std::iter::repeat((
+ core::iter::repeat((
  Transform(Mat4::from_scale(Vec3::ONE)),
  Rotation(Vec3::X),
  Position::<0>(Vec3::X),

diff --git a/benches/benches/bevy_ecs/iteration/mod.rs b/benches/benches/bevy_ecs/iteration/mod.rs
@@ -35,8 +35,8 @@ criterion_group!(
 
 fn iter_simple(c: &mut Criterion) {
  let mut group = c.benchmark_group("iter_simple");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("base", |b| {
  let mut bench = iter_simple::Benchmark::new();
  b.iter(move || bench.run());
@@ -82,8 +82,8 @@ fn iter_simple(c: &mut Criterion) {
 
 fn iter_frag(c: &mut Criterion) {
  let mut group = c.benchmark_group("iter_fragmented");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("base", |b| {
  let mut bench = iter_frag::Benchmark::new();
  b.iter(move || bench.run());
@@ -105,8 +105,8 @@ fn iter_frag(c: &mut Criterion) {
 
 fn iter_frag_sparse(c: &mut Criterion) {
  let mut group = c.benchmark_group("iter_fragmented_sparse");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  group.bench_function("base", |b| {
  let mut bench = iter_frag_sparse::Benchmark::new();
  b.iter(move || bench.run());
@@ -128,8 +128,8 @@ fn iter_frag_sparse(c: &mut Criterion) {
 
 fn par_iter_simple(c: &mut Criterion) {
  let mut group = c.benchmark_group("par_iter_simple");
- group.warm_up_time(std::time::Duration::from_millis(500));
- group.measurement_time(std::time::Duration::from_secs(4));
+ group.warm_up_time(core::time::Duration::from_millis(500));
+ group.measurement_time(core::time::Duration::from_secs(4));
  for f in [0, 10, 100, 1000] {
  group.bench_function(format!("with_{}_fragment", f), |b| {
  let mut bench = par_iter_simple::Benchmark::new(f);