Correctly update availability_info

mischnic · mischnic · commit 7e68f14245be · 2025-02-20T14:45:38.000+01:00
diff --git a/turbopack/crates/turbopack-browser/src/chunking_context.rs b/turbopack/crates/turbopack-browser/src/chunking_context.rs
@@ -9,9 +9,9 @@ use turbopack_core::{
         availability_info::AvailabilityInfo,
         chunk_group::{make_chunk_group, MakeChunkGroupResult},
         module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
-        Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
-        ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
-        SourceMapsType,
+        Chunk, ChunkGroupResult, ChunkGroupType, ChunkItem, ChunkableModule, ChunkingConfig,
+        ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType,
+        ModuleId, SourceMapsType,
     },
     environment::Environment,
     ident::AssetIdent,
@@ -425,13 +425,12 @@ impl ChunkingContext for BrowserChunkingContext {
         let span = tracing::info_span!("chunking", ident = ident.to_string().await?.to_string());
         async move {
             let this = self.await?;
-            let modules = chunk_group.entries();
             let input_availability_info = availability_info.into_value();
             let MakeChunkGroupResult {
                 chunks,
                 availability_info,
             } = make_chunk_group(
-                modules,
+                chunk_group,
                 module_graph,
                 ResolvedVc::upcast(self),
                 input_availability_info,
@@ -499,13 +498,17 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let entries = evaluatable_assets_ref
                 .iter()
-                .map(|&evaluatable| ResolvedVc::upcast(evaluatable));
+                .map(|&evaluatable| ResolvedVc::upcast(evaluatable))
+                .collect();
 
             let MakeChunkGroupResult {
                 chunks,
                 availability_info,
             } = make_chunk_group(
-                entries,
+                ChunkGroup::Entry {
+                    entries,
+                    ty: ChunkGroupType::Evaluated,
+                },
                 module_graph,
                 ResolvedVc::upcast(self),
                 availability_info,
diff --git a/turbopack/crates/turbopack-core/src/chunk/availability_info.rs b/turbopack/crates/turbopack-core/src/chunk/availability_info.rs
@@ -1,10 +1,7 @@
 use anyhow::Result;
-use turbo_tasks::{ResolvedVc, Vc};
+use turbo_tasks::ResolvedVc;
 
-use crate::{
-    chunk::available_chunk_groups::AvailableChunkGroups,
-    module_graph::chunk_group_info::RoaringBitmapWrapperCell,
-};
+use crate::chunk::available_chunk_groups::AvailableChunkGroups;
 
 #[turbo_tasks::value(serialization = "auto_for_input")]
 #[derive(Hash, Clone, Copy, Debug)]
@@ -30,7 +27,7 @@ impl AvailabilityInfo {
         }
     }
 
-    pub async fn with_modules(self, chunk_group: Vc<RoaringBitmapWrapperCell>) -> Result<Self> {
+    pub async fn with_modules(self, chunk_group: u32) -> Result<Self> {
         Ok(match self {
             AvailabilityInfo::Untracked => AvailabilityInfo::Untracked,
             AvailabilityInfo::Root => AvailabilityInfo::Complete {
diff --git a/turbopack/crates/turbopack-core/src/chunk/available_chunk_groups.rs b/turbopack/crates/turbopack-core/src/chunk/available_chunk_groups.rs
@@ -1,6 +1,7 @@
 use std::hash::{Hash, Hasher};
 
 use anyhow::Result;
+use roaring::RoaringBitmap;
 use rustc_hash::FxHasher;
 use turbo_tasks::Vc;
 
@@ -15,22 +16,20 @@ pub struct AvailableChunkGroups {
 #[turbo_tasks::value_impl]
 impl AvailableChunkGroups {
     #[turbo_tasks::function]
-    pub async fn new(chunk_groups: Vc<RoaringBitmapWrapperCell>) -> Result<Vc<Self>> {
+    pub async fn new(chunk_group: u32) -> Result<Vc<Self>> {
         Ok(AvailableChunkGroups {
-            chunk_groups: chunk_groups.owned().await?,
+            chunk_groups: RoaringBitmapWrapper::new(
+                RoaringBitmap::from_sorted_iter(std::iter::once(chunk_group)).unwrap(),
+            ),
         }
         .cell())
     }
 
     #[turbo_tasks::function]
-    pub async fn with_chunk_group(
-        &self,
-        chunk_group: Vc<RoaringBitmapWrapperCell>,
-    ) -> Result<Vc<Self>> {
-        Ok(AvailableChunkGroups {
-            chunk_groups: RoaringBitmapWrapper::new(&*self.chunk_groups | &**chunk_group.await?),
-        }
-        .cell())
+    pub async fn with_chunk_group(&self, chunk_group: u32) -> Result<Vc<Self>> {
+        let mut chunk_groups = self.chunk_groups.clone();
+        chunk_groups.insert(chunk_group);
+        Ok(AvailableChunkGroups { chunk_groups }.cell())
     }
 
     #[turbo_tasks::function]
diff --git a/turbopack/crates/turbopack-core/src/chunk/chunk_group.rs b/turbopack/crates/turbopack-core/src/chunk/chunk_group.rs
@@ -12,7 +12,7 @@ use crate::{
     chunk::ChunkingType,
     environment::ChunkLoading,
     module::Module,
-    module_graph::{GraphTraversalAction, ModuleGraph},
+    module_graph::{chunk_group_info::ChunkGroup, GraphTraversalAction, ModuleGraph},
     output::OutputAssets,
     reference::ModuleReference,
     traced_asset::TracedAsset,
@@ -25,7 +25,7 @@ pub struct MakeChunkGroupResult {
 
 /// Creates a chunk group from a set of entries.
 pub async fn make_chunk_group(
-    chunk_group_entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>,
+    chunk_group: ChunkGroup,
     module_graph: Vc<ModuleGraph>,
     chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
     availability_info: AvailabilityInfo,
@@ -42,7 +42,7 @@ pub async fn make_chunk_group(
         traced_modules,
     } = chunk_group_content(
         module_graph,
-        chunk_group_entries,
+        chunk_group.entries(),
         availability_info,
         can_split_async,
         should_trace,
@@ -76,11 +76,13 @@ pub async fn make_chunk_group(
         .collect::<FxIndexMap<_, Option<ResolvedVc<AsyncModuleInfo>>>>();
 
     // Compute new [AvailabilityInfo]
-    let own_chunk_group_info = module_graph
+    let current_chunk_group_idx = *module_graph
         .chunk_group_info()
-        // TODO which module should actually be looked up here?
-        .get(*ResolvedVc::upcast(*chunkable_modules.first().unwrap()));
-    let availability_info = availability_info.with_modules(own_chunk_group_info).await?;
+        .get_index_of(chunk_group)
+        .await? as u32;
+    let availability_info = availability_info
+        .with_modules(current_chunk_group_idx)
+        .await?;
 
     // Insert async chunk loaders for every referenced async module
     let async_loaders = async_modules
diff --git a/turbopack/crates/turbopack-nodejs/src/chunking_context.rs b/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
@@ -11,9 +11,9 @@ use turbopack_core::{
         availability_info::AvailabilityInfo,
         chunk_group::{make_chunk_group, MakeChunkGroupResult},
         module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
-        Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
-        ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
-        SourceMapsType,
+        Chunk, ChunkGroupResult, ChunkGroupType, ChunkItem, ChunkableModule, ChunkingConfig,
+        ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType,
+        ModuleId, SourceMapsType,
     },
     environment::Environment,
     ident::AssetIdent,
@@ -348,12 +348,11 @@ impl ChunkingContext for NodeJsChunkingContext {
     ) -> Result<Vc<ChunkGroupResult>> {
         let span = tracing::info_span!("chunking", module = ident.to_string().await?.to_string());
         async move {
-            let modules = chunk_group.entries();
             let MakeChunkGroupResult {
                 chunks,
                 availability_info,
             } = make_chunk_group(
-                modules,
+                chunk_group,
                 module_graph,
                 ResolvedVc::upcast(self),
                 availability_info.into_value(),
@@ -391,16 +390,22 @@ impl ChunkingContext for NodeJsChunkingContext {
     ) -> Result<Vc<EntryChunkGroupResult>> {
         let availability_info = availability_info.into_value();
 
-        let MakeChunkGroupResult {
-            chunks,
-            availability_info,
-        } = make_chunk_group(
-            once(module).chain(
+        let entries = once(module)
+            .chain(
                 evaluatable_assets
                     .await?
                     .iter()
                     .map(|&asset| ResolvedVc::upcast(asset)),
-            ),
+            )
+            .collect();
+        let MakeChunkGroupResult {
+            chunks,
+            availability_info,
+        } = make_chunk_group(
+            ChunkGroup::Entry {
+                entries,
+                ty: ChunkGroupType::Entry,
+            },
             module_graph,
             ResolvedVc::upcast(self),
             availability_info,
