turbopack: keep chunk compositions stable across item edits

Co-authored-by: Luke Sandberg <210140+lukesandberg@users.noreply.github.com>

Author: vercel-fleet-prod[bot]

turbopack/crates/turbo-tasks-fs/src/cell_rope.rs

@@ -50,7 +50,7 @@ use turbo_rcstr::RcStr;
 use turbo_tasks::{NonLocalValue, ResolvedVc, ValueToString, Vc, turbobail, turbofmt};
 
 pub use crate::{
-    cell_rope::{CellRope, CellRopeBuilder},
+    cell_rope::{CellRope, CellRopeBuilder, CellRopePart},
     content::{
         File, FileContent, FileJsonContent, FileLine, FileLinesContent, FileMeta, LinkContent,
         LinkTarget, Permissions, PersistedFileContent, WriteLinkContent, WriteLinkTargetType,

turbopack/crates/turbo-tasks-fs/src/lib.rs

@@ -8,7 +8,7 @@ use turbo_tasks_fs::FileContent;
 use turbopack_core::{
     asset::AssetContent,
     chunk::{ChunkingContext, ModuleId},
-    code_builder::{Code, ComposedCode, ComposedCodeBuilder},
+    code_builder::{Code, CodeComposition, CodeCompositionBuilder, ComposedCode},
     output::OutputAsset,
     source_map::{GenerateSourceMap, SourceMapAsset},
     version::{MergeableVersionedContent, Version, VersionedContent, VersionedContentMerger},
@@ -62,9 +62,27 @@ impl EcmascriptBrowserChunkContent {
         Ok(self.composed_code().await?.code())
     }
 
-    /// The chunk's code, composed from its chunk items' cells (see [`ComposedCode`]).
+    /// The chunk's code, built from its [`composition`](Self::composition).
     #[turbo_tasks::function]
     async fn composed_code(self: Vc<Self>) -> Result<Vc<ComposedCode>> {
+        let this = self.await?;
+        let source_maps = *this
+            .chunking_context
+            .reference_chunk_source_maps(*ResolvedVc::upcast(this.chunk))
+            .await?;
+        let minification =
+            ChunkMinification::for_chunking_context(Vc::upcast(*this.chunking_context)).await?;
+        Ok(minification
+            .finish_composition(self.composition().to_resolved().await?, source_maps)
+            .await?
+            .cell())
+    }
+
+    /// The chunk's structure: its scaffolding, and references to its chunk items' cells (see
+    /// [`CodeComposition`]). Doesn't read the chunk items' bytes, so it isn't recomputed (and its
+    /// persisted body isn't rewritten) when only those change.
+    #[turbo_tasks::function]
+    async fn composition(self: Vc<Self>) -> Result<Vc<CodeComposition>> {
         let this = self.await?;
         let source_maps = *this
             .chunking_context
@@ -88,7 +106,7 @@ impl EcmascriptBrowserChunkContent {
                 Either::Right(CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR)
             }
         };
-        let mut code = ComposedCodeBuilder::new(
+        let mut code = CodeCompositionBuilder::new(
             source_maps,
             *this.chunking_context.debug_ids_enabled().await?,
         );
@@ -142,10 +160,7 @@ impl EcmascriptBrowserChunkContent {
         )?;
         code += "]);";
 
-        let (code, parts) = code.build();
-        Ok(minification
-            .finish_composed_chunk(code, parts, source_maps)?
-            .cell())
+        Ok(code.build().cell())
     }
 
     #[turbo_tasks::function]