turbo-tasks: TinyVec API hardening + const-generic MAX

* Tighten visibility: `new`, `capacity`, `as_slice`, `as_mut_slice`,
  `reserve` are now private. `len` and `is_empty` stay pub as a clippy-
  preferred pair.
* Replace the hand-rolled `retain_mut` (~7 unsafe blocks with a panic
  partial-shift guard) with delegation to `Vec::retain_mut` via a
  Vec::from_raw_parts round-trip. retain_mut is cold relative to push
  so the round-trip cost is irrelevant.
* Replace the hand-rolled owned `IntoIter` (custom struct + Iterator,
  Drop, ExactSizeIterator impls) with delegation to `std::vec::IntoIter`
  via the same Vec round-trip. Drops ~50 lines of unsafe.
* Drop `Extend` and `FromIterator` trait impls entirely — no external
  callers. Replace with inherent `extend_exact` which requires an
  `ExactSizeIterator` and reserves exactly once.
* Drop inherent `iter`, `iter_mut`, `last_mut`, `Index`, `IndexMut`
  impls — all reachable through `Deref<Target = [T]>` to the slice's
  methods. `for x in &tv` / `for x in &mut tv` still need `IntoIterator`
  impls for refs because the `for`-loop desugar doesn't apply `Deref`
  coercion across the reference boundary.
* Add a `const MAX: u8` generic parameter that strictly caps push count
  and tightens the growth schedule (doubles until it would exceed MAX,
  then caps exactly at MAX). Default is `u8::MAX = 255` for backward
  compatibility; the schema macro emits `TinyVec<LazyField, N>` where N
  is the exact lazy-field count. A compile-time static assert rejects
  `MAX = 0` at monomorphization.
* Add 3 const-generic tests (tight_max_caps_growth_exactly,
  tight_max_panics_at_limit, tight_max_growth_schedule) and 6
  retain_mut tests (basic, can_mutate, empty, keeps_all, removes_all,
  panic_safety, element_drop_panic).

Net effect: unsafe blocks went from ~19 (in the original hand-rolled
version) to 5 in the hot path plus 1 in retain_mut and 1 in IntoIter
— each upholding a single local invariant or just round-tripping
through Vec.

Author: lukesandberg

turbopack/crates/turbo-tasks-backend/src/backend/operation/cleanup_old_edges.rs

@@ -176,10 +176,6 @@ impl CleanupOldEdgesOperation {
                                 ) = dep.into_parts();
                                 {
                                     let mut task = ctx.task(cell_task_id, TaskDataCategory::Data);
-                                    // The `cell_dependents` set on the dependee task is keyed
-                                    // by `(cell, task_id, key)`. Re-encode that as a
-                                    // `CellDependency` whose `CellRef.task` is the dependent
-                                    // task — same bits, opposite direction.
                                     task.remove_cell_dependents(&CellDependency::new(
                                         CellRef {
                                             task: task_id,

turbopack/crates/turbo-tasks-backend/src/backend/operation/update_cell.rs

@@ -138,8 +138,6 @@ impl UpdateCellOperation {
                 FxIndexMap::default();
             if !skip_invalidation {
                 let tasks_with_keys = task.iter_cell_dependents().filter_map(|dep| {
-                    // `cell_dependents` reuses `CellDependency`, but with the dependent task
-                    // stored in `CellRef.task` and the storing task's cell in `CellRef.cell`.
                     let (
                         CellRef {
                             task: dependent_task,

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

@@ -85,12 +85,6 @@ impl CollectiblesRef {
 /// - In `cell_dependents`, the [`CellRef`]'s `task` is the dependent task and `cell` is the cell of
 ///   the storing task; the `task` field is reused as the dependent's id rather than the cell's
 ///   owning task. The fields encode the same bits either way.
-///
-/// Replaces the old `(CellRef, Option<u64>)` and `(CellId, Option<u64>, TaskId)` tuples. The
-/// `Option<u64>` previously cost a full 16 B (8 B discriminant + 8 B value, aligned). With an
-/// explicit enum the layout algorithm reuses the niche on `ValueTypeId` (`NonZero<u16>`)
-/// inside `CellRef.cell.type_id` for the variant tag, dropping the element from 32 B to 24 B.
-/// That in turn shrinks `LazyField` from 56 B to 48 B.
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Encode, Decode)]
 pub enum CellDependency {
     /// Depend on the cell as a whole.

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

@@ -1296,12 +1296,21 @@ fn generate_typed_storage_struct(grouped_fields: &GroupedFields) -> TokenStream
         quote! {}
     };
 
-    // `TinyVec` is resolved at the schema's call site — the schema must
-    // `use turbo_tasks::TinyVec` (or otherwise have it in scope).
     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;
         quote! {
             #[doc = "Lazily-allocated fields stored in a compact TinyVec for memory efficiency"]
-            lazy: TinyVec<LazyField>,
+            lazy: TinyVec<LazyField, #max_lazy>,
         }
     } else {
         quote! {}
@@ -3686,10 +3695,10 @@ fn generate_snapshot_restore_methods(grouped_fields: &GroupedFields) -> TokenStr
 
                 #clone_all_flags
 
-                // Pre-allocate lazy vec (upper bound - some may be transient and skipped)
-                snapshot.lazy.reserve(self.lazy.len());
-
-                // Clone all persistent lazy fields (both meta and data)
+                // Clone all persistent lazy fields (both meta and data).
+                // (No pre-`reserve`: the schema has ≤24 lazy fields, so at most 3 grows
+                // (0→4→8→16→24) total — cheaper than complicating the public API surface
+                // of `TinyVec`.)
                 for field in &self.lazy {
                     match field {
                         #(#clone_data_lazy_arms)*
@@ -3746,7 +3755,7 @@ fn generate_snapshot_restore_methods(grouped_fields: &GroupedFields) -> TokenStr
                 // and merge each source variant in O(1).
                 let (any_meta, _any_data, index) = Self::build_lazy_index(&self.lazy);
                 if !any_meta {
-                    self.lazy.extend(source.lazy);
+                    self.lazy.extend_exact(source.lazy);
                 } else {
                     for field in source.lazy {
                         debug_assert!(field.is_persistent() && field.is_meta());
@@ -3770,7 +3779,7 @@ fn generate_snapshot_restore_methods(grouped_fields: &GroupedFields) -> TokenStr
                 // in `self.lazy` is never a collision risk.
                 let (_any_meta, any_data, index) = Self::build_lazy_index(&self.lazy);
                 if !any_data {
-                    self.lazy.extend(source.lazy);
+                    self.lazy.extend_exact(source.lazy);
                 } else {
                     for field in source.lazy {
                         debug_assert!(field.is_persistent() && field.is_data());

turbopack/crates/turbo-tasks/benches/tiny_vec.rs

@@ -45,7 +45,7 @@ fn push_vec(n: usize) -> Vec<Item> {
 }
 
 fn push_tinyvec(n: usize) -> TinyVec<Item> {
-    let mut v: TinyVec<Item> = TinyVec::new();
+    let mut v: TinyVec<Item> = TinyVec::default();
     for i in 0..n {
         v.push(make_item(i as u64));
     }