address review feedback

Author: lukesandberg

turbopack/crates/turbo-tasks-backend/src/backend/storage_schema.rs

@@ -17,9 +17,13 @@
 //! - `data` - Frequently changed bulk data (dependencies, cell data)
 //! - `meta` - Rarely changed metadata (output, aggregation, flags)
 //! - `transient` - Not serialized, only exists in memory
-use std::{hash::Hash, sync::Arc};
+use std::{
+    hash::{BuildHasherDefault, Hash},
+    sync::Arc,
+};
 
 use parking_lot::Mutex;
+use rustc_hash::FxHasher;
 use turbo_tasks::{
     CellId, SharedReference, TaskExecutionReason, TaskId, TinyVec, TraitTypeId, ValueTypeId,
     backend::{CachedTaskTypeArc, CellHash, TransientTaskType},
@@ -36,20 +40,12 @@ use crate::{
     },
 };
 
-/// Auto-set storage for small sets of keys with unit values.
-///
-/// The `I` const generic is the inline capacity — entries spill to a `HashSet`
-/// past it. Each field below picks its own `I` to saturate the available
-/// padding (in `LazyField`) or to stay within the 16-byte `SmallVec` free
-/// zone (for inline fields); see the field comments for the rationale.
-type AutoSet<K, const I: usize> =
-    auto_hash_map::AutoSet<K, std::hash::BuildHasherDefault<rustc_hash::FxHasher>, I>;
+type AutoSet<K, const I: usize> = auto_hash_map::AutoSet<K, BuildHasherDefault<FxHasher>, I>;
 
 /// Auto-map storage for key-value pairs.
 ///
 /// See [`AutoSet`] for the meaning of `I`.
-type AutoMap<K, V, const I: usize> =
-    auto_hash_map::AutoMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>, I>;
+type AutoMap<K, V, const I: usize> = auto_hash_map::AutoMap<K, V, BuildHasherDefault<FxHasher>, I>;
 
 /// The complete task storage schema.
 ///

turbopack/crates/turbo-tasks-macros/src/derive/task_storage_macro.rs

@@ -1297,17 +1297,12 @@ fn generate_typed_storage_struct(grouped_fields: &GroupedFields) -> TokenStream
     };
 
     let lazy_field = if has_lazy {
-        // `TinyVec`'s `MAX` const generic is set to the exact number of lazy fields declared
-        // in the schema. This caps growth at the smallest power-of-two-or-MAX boundary
-        // (e.g. with 24 variants we end at cap=24 instead of cap=32), saving a few slots
-        // per fully-populated task. It also makes "push past MAX" a compile-time-bounded
-        // contract instead of relying on `u8::MAX`.
-        //
-        // `as u8` cast is safe at the macro layer: u8::MAX is plenty of room for any
-        // realistic schema (asserted at compile time by `TinyVec::new`'s `MAX > 0` guard
-        // — a runtime check is not strictly required because the macro itself wouldn't
-        // emit > 255 variants).
-        let max_lazy = grouped_fields.all_lazy().count() as u8;
+        let max_lazy: u8 = grouped_fields
+            .all_lazy()
+            .count()
+            .try_into()
+            .expect("cannot have more than 255 lazy fields");
+
         quote! {
             #[doc = "Lazily-allocated fields stored in a compact TinyVec for memory efficiency"]
             lazy: TinyVec<LazyField, #max_lazy>,