Revert "Chunking Context Refactor pt. 3: Address PR comments from pt.…

… 2" (vercel#4588)

Reverts vercel#4546

crates/turbopack-core/src/chunk/mod.rs

@@ -1,7 +1,6 @@
 pub mod availability_info;
 pub mod available_assets;
 pub(crate) mod chunking_context;
-pub(crate) mod containment_tree;
 pub(crate) mod evaluate;
 pub mod optimize;
 
@@ -17,7 +16,7 @@ use serde::{Deserialize, Serialize};
 use turbo_tasks::{
     debug::ValueDebugFormat,
     graph::{GraphTraversal, GraphTraversalResult, ReverseTopological, Visit, VisitControlFlow},
-    primitives::StringVc,
+    primitives::{BoolVc, StringVc},
     trace::TraceRawVcs,
     TryJoinIterExt, Value, ValueToString, ValueToStringVc,
 };
@@ -28,6 +27,7 @@ use self::availability_info::AvailabilityInfo;
 pub use self::{
     chunking_context::{ChunkingContext, ChunkingContextVc},
     evaluate::{EvaluatableAsset, EvaluatableAssetVc, EvaluatableAssets, EvaluatableAssetsVc},
+    optimize::optimize,
 };
 use crate::{
     asset::{Asset, AssetVc, AssetsVc},
@@ -97,17 +97,13 @@ pub trait ChunkableAsset: Asset {
 #[turbo_tasks::value(transparent)]
 pub struct Chunks(Vec<ChunkVc>);
 
-#[turbo_tasks::value_impl]
-impl ChunksVc {
-    /// Creates a new empty [ChunksVc].
-    #[turbo_tasks::function]
-    pub fn empty() -> ChunksVc {
-        Self::cell(vec![])
-    }
-}
-
 /// A chunk is one type of asset.
 /// It usually contains multiple chunk items.
+/// There is an optional trait [ParallelChunkReference] that
+/// [AssetReference]s from a [Chunk] can implement.
+/// If they implement that and [ParallelChunkReference::is_loaded_in_parallel]
+/// returns true, all referenced assets (if they are [Chunk]s) are placed in the
+/// same chunk group.
 #[turbo_tasks::value_trait]
 pub trait Chunk: Asset {
     fn chunking_context(&self) -> ChunkingContextVc;
@@ -118,11 +114,12 @@ pub trait Chunk: Asset {
     fn path(&self) -> FileSystemPathVc {
         self.ident().path()
     }
-    /// Returns a list of chunks that should be loaded in parallel to this
-    /// chunk.
-    fn parallel_chunks(&self) -> ChunksVc {
-        ChunksVc::empty()
-    }
+}
+
+/// see [Chunk] for explanation
+#[turbo_tasks::value_trait]
+pub trait ParallelChunkReference: AssetReference + ValueToString {
+    fn is_loaded_in_parallel(&self) -> BoolVc;
 }
 
 /// Specifies how a chunk interacts with other chunks when building a chunk
@@ -169,6 +166,59 @@ pub trait ChunkableAssetReference: AssetReference + ValueToString {
     }
 }
 
+/// A reference to a [Chunk]. Can be loaded in parallel, see [Chunk].
+#[turbo_tasks::value]
+pub struct ChunkReference {
+    chunk: ChunkVc,
+    parallel: bool,
+}
+
+#[turbo_tasks::value_impl]
+impl ChunkReferenceVc {
+    #[turbo_tasks::function]
+    pub fn new(chunk: ChunkVc) -> Self {
+        Self::cell(ChunkReference {
+            chunk,
+            parallel: false,
+        })
+    }
+
+    #[turbo_tasks::function]
+    pub fn new_parallel(chunk: ChunkVc) -> Self {
+        Self::cell(ChunkReference {
+            chunk,
+            parallel: true,
+        })
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl AssetReference for ChunkReference {
+    #[turbo_tasks::function]
+    fn resolve_reference(&self) -> ResolveResultVc {
+        ResolveResult::asset(self.chunk.into()).into()
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl ValueToString for ChunkReference {
+    #[turbo_tasks::function]
+    async fn to_string(&self) -> Result<StringVc> {
+        Ok(StringVc::cell(format!(
+            "chunk {}",
+            self.chunk.ident().to_string().await?
+        )))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl ParallelChunkReference for ChunkReference {
+    #[turbo_tasks::function]
+    fn is_loaded_in_parallel(&self) -> BoolVc {
+        BoolVc::cell(self.parallel)
+    }
+}
+
 /// A reference to multiple chunks from a [ChunkGroup]
 #[turbo_tasks::value]
 pub struct ChunkGroupReference {