[DRAFT] no_std Option for bevy_tasks

Cargo.toml

@@ -45,15 +45,53 @@ ptr_as_ptr = "warn"
 ptr_cast_constness = "warn"
 ref_as_ptr = "warn"
 
+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"
+
+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 = [

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>(

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());

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);
         }
     }
 }

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);

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();
     }

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();

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);
 

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),

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),

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),

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),

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),

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),

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),

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),

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),

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);