From 59ac1533324bfac62e75d759dd6cdee0f44a0b96 Mon Sep 17 00:00:00 2001 From: Justin Ridgewell Date: Fri, 6 Oct 2023 01:55:33 -0400 Subject: [PATCH] Chunking Refactor Step 2 (#6120) ### Description The second step in our chunking refactoring, this removes our use of `Module::as_chunk` and `Module::as_root_chunk`. Instead, the only way to generate a chunk is directly from a root `ChunkItem`. Re: https://github.com/vercel/turbo/pull/6104 ### Testing Instructions Closes WEB-1720 --------- Co-authored-by: Tobias Koppers --- .../turbopack-build/src/chunking_context.rs | 25 +++- crates/turbopack-cli/src/build/mod.rs | 4 +- .../src/chunk/chunking_context.rs | 29 ++++- crates/turbopack-core/src/chunk/mod.rs | 107 ++---------------- crates/turbopack-dev-server/src/html.rs | 16 ++- crates/turbopack-dev/src/chunking_context.rs | 36 +++--- .../src/ecmascript/evaluate/chunk.rs | 16 +-- .../src/ecmascript/list/asset.rs | 10 +- .../src/chunk_group_files_asset.rs | 18 +-- .../src/manifest/chunk_asset.rs | 25 ++-- crates/turbopack-node/src/bootstrap.rs | 5 +- crates/turbopack-node/src/evaluate.rs | 3 +- crates/turbopack-node/src/lib.rs | 3 +- crates/turbopack-tests/tests/snapshot.rs | 8 +- 14 files changed, 130 insertions(+), 175 deletions(-) diff --git a/crates/turbopack-build/src/chunking_context.rs b/crates/turbopack-build/src/chunking_context.rs index 3f2ee63d1db4e..8b034921d0f5c 100644 --- a/crates/turbopack-build/src/chunking_context.rs +++ b/crates/turbopack-build/src/chunking_context.rs @@ -8,7 +8,10 @@ use turbo_tasks::{ }; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ - chunk::{Chunk, ChunkableModuleExt, ChunkingContext, Chunks, EvaluatableAssets}, + chunk::{ + availability_info::AvailabilityInfo, Chunk, ChunkItem, ChunkableModule, ChunkingContext, + Chunks, EvaluatableAssets, + }, environment::Environment, ident::AssetIdent, module::Module, @@ -163,7 +166,12 @@ impl BuildChunkingContext { module: Vc>, evaluatable_assets: Vc, ) -> Result>> { - let entry_chunk = module.as_root_chunk(Vc::upcast(self)); + let entry_chunk = + module + .as_chunk_item(Vc::upcast(self)) + .as_chunk(Value::new(AvailabilityInfo::Root { + current_availability_root: Vc::upcast(module), + })); let other_chunks = self .get_chunk_assets(entry_chunk, evaluatable_assets) @@ -214,7 +222,10 @@ impl BuildChunkingContext { .map({ move |evaluatable_asset| async move { evaluatable_asset - .as_root_chunk(Vc::upcast(self)) + .as_chunk_item(Vc::upcast(self)) + .as_chunk(Value::new(AvailabilityInfo::Root { + current_availability_root: Vc::upcast(*evaluatable_asset), + })) .resolve() .await } @@ -350,8 +361,12 @@ impl ChunkingContext for BuildChunkingContext { #[turbo_tasks::function] async fn chunk_group( self: Vc, - entry_chunk: Vc>, + module: Vc>, + availability_info: Value, ) -> Result> { + let entry_chunk = module + .as_chunk_item(Vc::upcast(self)) + .as_chunk(availability_info); let parallel_chunks = get_parallel_chunks([entry_chunk]).await?; let optimized_chunks = get_optimized_chunks(parallel_chunks).await?; @@ -368,7 +383,7 @@ impl ChunkingContext for BuildChunkingContext { #[turbo_tasks::function] async fn evaluated_chunk_group( self: Vc, - _entry_chunk: Vc>, + _ident: Vc, _evaluatable_assets: Vc, ) -> Result> { // TODO(alexkirsz) This method should be part of a separate trait that is diff --git a/crates/turbopack-cli/src/build/mod.rs b/crates/turbopack-cli/src/build/mod.rs index 23453b6bf7ec3..526189fc9eadb 100644 --- a/crates/turbopack-cli/src/build/mod.rs +++ b/crates/turbopack-cli/src/build/mod.rs @@ -14,7 +14,7 @@ use turbopack_build::{BuildChunkingContext, MinifyType}; use turbopack_cli_utils::issue::{ConsoleUi, LogOptions}; use turbopack_core::{ asset::Asset, - chunk::{ChunkableModule, ChunkableModuleExt, ChunkingContext, EvaluatableAssets}, + chunk::{ChunkableModule, ChunkingContextExt, EvaluatableAssets}, environment::{BrowserEnvironment, Environment, ExecutionEnvironment}, issue::{handle_issues, IssueReporter, IssueSeverity}, module::Module, @@ -269,7 +269,7 @@ async fn build_internal( } else if let Some(chunkable) = Vc::try_resolve_sidecast::>(entry_module).await? { - chunking_context.chunk_group(chunkable.as_root_chunk(chunking_context)) + chunking_context.root_chunk_group(chunkable) } else { // TODO convert into a serve-able asset bail!( diff --git a/crates/turbopack-core/src/chunk/chunking_context.rs b/crates/turbopack-core/src/chunk/chunking_context.rs index 9fbf680cee0f3..4f21610492d37 100644 --- a/crates/turbopack-core/src/chunk/chunking_context.rs +++ b/crates/turbopack-core/src/chunk/chunking_context.rs @@ -1,8 +1,8 @@ use anyhow::Result; -use turbo_tasks::{ValueToString, Vc}; +use turbo_tasks::{Upcast, Value, ValueToString, Vc}; use turbo_tasks_fs::FileSystemPath; -use super::{Chunk, EvaluatableAssets}; +use super::{availability_info::AvailabilityInfo, ChunkableModule, EvaluatableAssets}; use crate::{ chunk::{ChunkItem, ModuleId}, environment::Environment, @@ -57,11 +57,15 @@ pub trait ChunkingContext { fn with_layer(self: Vc, layer: String) -> Vc; - fn chunk_group(self: Vc, entry: Vc>) -> Vc; + fn chunk_group( + self: Vc, + module: Vc>, + availability_info: Value, + ) -> Vc; fn evaluated_chunk_group( self: Vc, - entry: Vc>, + ident: Vc, evaluatable_assets: Vc, ) -> Vc; @@ -77,3 +81,20 @@ pub trait ChunkingContext { Ok(ModuleId::String(ident.to_string().await?.clone_value()).cell()) } } + +pub trait ChunkingContextExt { + fn root_chunk_group(self: Vc, module: Vc>) -> Vc + where + Self: Send; +} + +impl>> ChunkingContextExt for T { + fn root_chunk_group(self: Vc, module: Vc>) -> Vc { + self.chunk_group( + module, + Value::new(AvailabilityInfo::Root { + current_availability_root: Vc::upcast(module), + }), + ) + } +} diff --git a/crates/turbopack-core/src/chunk/mod.rs b/crates/turbopack-core/src/chunk/mod.rs index 3b425c362effa..dc0d738870ed1 100644 --- a/crates/turbopack-core/src/chunk/mod.rs +++ b/crates/turbopack-core/src/chunk/mod.rs @@ -29,7 +29,7 @@ use turbo_tasks_hash::DeterministicHash; use self::availability_info::AvailabilityInfo; pub use self::{ - chunking_context::ChunkingContext, + chunking_context::{ChunkingContext, ChunkingContextExt}, data::{ChunkData, ChunkDataOption, ChunksData}, evaluate::{EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets}, passthrough_asset::PassthroughModule, @@ -40,7 +40,6 @@ use crate::{ module::{Module, Modules}, output::OutputAssets, reference::{ModuleReference, ModuleReferences}, - resolve::ModuleResolveResult, }; /// A module id, which can be a number or string @@ -91,43 +90,6 @@ pub trait ChunkableModule: Module + Asset { ) -> Vc>; } -pub trait ChunkableModuleExt { - fn as_chunk( - self: Vc, - chunking_context: Vc>, - availability_info: Value, - ) -> Vc> - where - Self: Send; - fn as_root_chunk( - self: Vc, - chunking_context: Vc>, - ) -> Vc> - where - Self: Send; -} - -impl>> ChunkableModuleExt for T { - fn as_chunk( - self: Vc, - chunking_context: Vc>, - availability_info: Value, - ) -> Vc> { - let chunk_item = self.as_chunk_item(chunking_context); - chunk_item.as_chunk(availability_info) - } - - fn as_root_chunk( - self: Vc, - chunking_context: Vc>, - ) -> Vc> { - let chunk_item = self.as_chunk_item(chunking_context); - chunk_item.as_chunk(Value::new(AvailabilityInfo::Root { - current_availability_root: Vc::upcast(self), - })) - } -} - #[turbo_tasks::value(transparent)] pub struct Chunks(Vec>>); @@ -224,53 +186,6 @@ pub trait ChunkableModuleReference: ModuleReference + ValueToString { } } -/// A reference to multiple chunks from a [ChunkGroup] -#[turbo_tasks::value] -pub struct ChunkGroupReference { - chunking_context: Vc>, - entry: Vc>, -} - -#[turbo_tasks::value_impl] -impl ChunkGroupReference { - #[turbo_tasks::function] - pub fn new( - chunking_context: Vc>, - entry: Vc>, - ) -> Vc { - Self::cell(ChunkGroupReference { - chunking_context, - entry, - }) - } - - #[turbo_tasks::function] - async fn chunks(self: Vc) -> Result> { - let this = self.await?; - Ok(this.chunking_context.chunk_group(this.entry)) - } -} - -#[turbo_tasks::value_impl] -impl ModuleReference for ChunkGroupReference { - #[turbo_tasks::function] - async fn resolve_reference(self: Vc) -> Result> { - let set = self.chunks().await?.clone_value(); - Ok(ModuleResolveResult::output_assets(set).cell()) - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for ChunkGroupReference { - #[turbo_tasks::function] - async fn to_string(&self) -> Result> { - Ok(Vc::cell(format!( - "chunk group ({})", - self.entry.ident().to_string().await? - ))) - } -} - pub struct ChunkContentResult { pub chunk_items: Vec, pub chunks: Vec>>, @@ -440,17 +355,20 @@ where } } ChunkingType::Parallel => { - let chunk = chunkable_module.as_chunk( - chunk_content_context.chunking_context, - chunk_content_context.availability_info, - ); + let chunk = chunkable_module + .as_chunk_item(chunk_content_context.chunking_context) + .as_chunk(chunk_content_context.availability_info); graph_nodes.push(( Some((module, chunking_type)), ChunkContentGraphNode::Chunk(chunk), )); } ChunkingType::IsolatedParallel => { - let chunk = chunkable_module.as_root_chunk(chunk_content_context.chunking_context); + let chunk = chunkable_module + .as_chunk_item(chunk_content_context.chunking_context) + .as_chunk(Value::new(AvailabilityInfo::Root { + current_availability_root: Vc::upcast(chunkable_module), + })); graph_nodes.push(( Some((module, chunking_type)), ChunkContentGraphNode::Chunk(chunk), @@ -479,10 +397,9 @@ where } } - let chunk = chunkable_module.as_chunk( - chunk_content_context.chunking_context, - chunk_content_context.availability_info, - ); + let chunk = chunkable_module + .as_chunk_item(chunk_content_context.chunking_context) + .as_chunk(chunk_content_context.availability_info); graph_nodes.push(( Some((module, chunking_type)), ChunkContentGraphNode::Chunk(chunk), diff --git a/crates/turbopack-dev-server/src/html.rs b/crates/turbopack-dev-server/src/html.rs index 13e60ae7b290f..29fc8da9b33a4 100644 --- a/crates/turbopack-dev-server/src/html.rs +++ b/crates/turbopack-dev-server/src/html.rs @@ -5,8 +5,9 @@ use turbo_tasks_fs::{File, FileSystemPath}; use turbo_tasks_hash::{encode_hex, Xxh3Hash64Hasher}; use turbopack_core::{ asset::{Asset, AssetContent}, - chunk::{ChunkableModule, ChunkableModuleExt, ChunkingContext, EvaluatableAssets}, + chunk::{ChunkableModule, ChunkingContext, ChunkingContextExt, EvaluatableAssets}, ident::AssetIdent, + module::Module, output::{OutputAsset, OutputAssets}, version::{Version, VersionedContent}, }; @@ -131,11 +132,18 @@ impl DevHtmlAsset { .map(|entry| async move { let (chunkable_module, chunking_context, runtime_entries) = entry; - let chunk = chunkable_module.as_root_chunk(*chunking_context); let assets = if let Some(runtime_entries) = runtime_entries { - chunking_context.evaluated_chunk_group(chunk, *runtime_entries) + let runtime_entries = if let Some(evaluatable) = + Vc::try_resolve_downcast(*chunkable_module).await? + { + runtime_entries.with_entry(evaluatable) + } else { + *runtime_entries + }; + chunking_context + .evaluated_chunk_group(chunkable_module.ident(), runtime_entries) } else { - chunking_context.chunk_group(chunk) + chunking_context.root_chunk_group(Vc::upcast(*chunkable_module)) }; assets.await diff --git a/crates/turbopack-dev/src/chunking_context.rs b/crates/turbopack-dev/src/chunking_context.rs index b9b52099fad4a..d700681d6fd5f 100644 --- a/crates/turbopack-dev/src/chunking_context.rs +++ b/crates/turbopack-dev/src/chunking_context.rs @@ -6,7 +6,10 @@ use turbo_tasks::{ }; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ - chunk::{Chunk, ChunkableModuleExt, ChunkingContext, Chunks, EvaluatableAssets}, + chunk::{ + availability_info::AvailabilityInfo, Chunk, ChunkItem, ChunkableModule, ChunkingContext, + Chunks, EvaluatableAssets, + }, environment::Environment, ident::AssetIdent, module::Module, @@ -160,13 +163,13 @@ impl DevChunkingContext { #[turbo_tasks::function] fn generate_evaluate_chunk( self: Vc, - entry_chunk: Vc>, + ident: Vc, other_chunks: Vc, evaluatable_assets: Vc, ) -> Vc> { Vc::upcast(EcmascriptDevEvaluateChunk::new( self, - entry_chunk, + ident, other_chunks, evaluatable_assets, )) @@ -175,14 +178,14 @@ impl DevChunkingContext { #[turbo_tasks::function] fn generate_chunk_list_register_chunk( self: Vc, - entry_chunk: Vc>, + ident: Vc, evaluatable_assets: Vc, other_chunks: Vc, source: Value, ) -> Vc> { Vc::upcast(EcmascriptDevChunkList::new( self, - entry_chunk, + ident, evaluatable_assets, other_chunks, source, @@ -340,8 +343,12 @@ impl ChunkingContext for DevChunkingContext { #[turbo_tasks::function] async fn chunk_group( self: Vc, - entry_chunk: Vc>, + module: Vc>, + availability_info: Value, ) -> Result> { + let entry_chunk = module + .as_chunk_item(Vc::upcast(self)) + .as_chunk(availability_info); let parallel_chunks = get_parallel_chunks([entry_chunk]).await?; let optimized_chunks = get_optimized_chunks(parallel_chunks).await?; @@ -353,7 +360,7 @@ impl ChunkingContext for DevChunkingContext { .collect(); assets.push(self.generate_chunk_list_register_chunk( - entry_chunk, + entry_chunk.ident(), EvaluatableAssets::empty(), Vc::cell(assets.clone()), Value::new(EcmascriptDevChunkListSource::Dynamic), @@ -365,17 +372,20 @@ impl ChunkingContext for DevChunkingContext { #[turbo_tasks::function] async fn evaluated_chunk_group( self: Vc, - entry_chunk: Vc>, + ident: Vc, evaluatable_assets: Vc, ) -> Result> { let evaluatable_assets_ref = evaluatable_assets.await?; - let mut entry_assets: IndexSet<_> = evaluatable_assets_ref + let entry_assets: IndexSet<_> = evaluatable_assets_ref .iter() .map({ move |evaluatable_asset| async move { evaluatable_asset - .as_root_chunk(Vc::upcast(self)) + .as_chunk_item(Vc::upcast(self)) + .as_chunk(Value::new(AvailabilityInfo::Root { + current_availability_root: Vc::upcast(*evaluatable_asset), + })) .resolve() .await } @@ -385,8 +395,6 @@ impl ChunkingContext for DevChunkingContext { .into_iter() .collect(); - entry_assets.insert(entry_chunk.resolve().await?); - let parallel_chunks = get_parallel_chunks(entry_assets).await?; let optimized_chunks = get_optimized_chunks(parallel_chunks).await?; @@ -400,13 +408,13 @@ impl ChunkingContext for DevChunkingContext { let other_assets = Vc::cell(assets.clone()); assets.push(self.generate_chunk_list_register_chunk( - entry_chunk, + ident, evaluatable_assets, other_assets, Value::new(EcmascriptDevChunkListSource::Entry), )); - assets.push(self.generate_evaluate_chunk(entry_chunk, other_assets, evaluatable_assets)); + assets.push(self.generate_evaluate_chunk(ident, other_assets, evaluatable_assets)); Ok(Vc::cell(assets)) } diff --git a/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs b/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs index a6e1e92865b74..77f1a9dd1c5c9 100644 --- a/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs +++ b/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs @@ -8,8 +8,8 @@ use turbo_tasks_fs::File; use turbopack_core::{ asset::{Asset, AssetContent}, chunk::{ - Chunk, ChunkData, ChunkItemExt, ChunkableModule, ChunkingContext, ChunksData, - EvaluatableAssets, ModuleId, + ChunkData, ChunkItemExt, ChunkableModule, ChunkingContext, ChunksData, EvaluatableAssets, + ModuleId, }, code_builder::{Code, CodeBuilder}, ident::AssetIdent, @@ -31,7 +31,7 @@ use crate::DevChunkingContext; #[turbo_tasks::value(shared)] pub(crate) struct EcmascriptDevEvaluateChunk { chunking_context: Vc, - entry_chunk: Vc>, + ident: Vc, other_chunks: Vc, evaluatable_assets: Vc, } @@ -42,13 +42,13 @@ impl EcmascriptDevEvaluateChunk { #[turbo_tasks::function] pub fn new( chunking_context: Vc, - entry_chunk: Vc>, + ident: Vc, other_chunks: Vc, evaluatable_assets: Vc, ) -> Vc { EcmascriptDevEvaluateChunk { chunking_context, - entry_chunk, + ident, other_chunks, evaluatable_assets, } @@ -181,13 +181,13 @@ fn modifier() -> Vc { impl OutputAsset for EcmascriptDevEvaluateChunk { #[turbo_tasks::function] async fn ident(&self) -> Result> { - let mut ident = self.entry_chunk.ident().await?.clone_value(); + let mut ident = self.ident.await?.clone_value(); ident.add_modifier(modifier()); + let evaluatable_assets = self.evaluatable_assets.await?; ident.modifiers.extend( - self.evaluatable_assets - .await? + evaluatable_assets .iter() .map(|entry| entry.ident().to_string()), ); diff --git a/crates/turbopack-dev/src/ecmascript/list/asset.rs b/crates/turbopack-dev/src/ecmascript/list/asset.rs index 7796845cdba5c..b27a93c997f37 100644 --- a/crates/turbopack-dev/src/ecmascript/list/asset.rs +++ b/crates/turbopack-dev/src/ecmascript/list/asset.rs @@ -3,7 +3,7 @@ use serde::Serialize; use turbo_tasks::{Value, ValueToString, Vc}; use turbopack_core::{ asset::{Asset, AssetContent}, - chunk::{Chunk, ChunkingContext, EvaluatableAssets}, + chunk::{ChunkingContext, EvaluatableAssets}, ident::AssetIdent, module::Module, output::{OutputAsset, OutputAssets}, @@ -27,7 +27,7 @@ use crate::DevChunkingContext; #[turbo_tasks::value(shared)] pub(crate) struct EcmascriptDevChunkList { pub(super) chunking_context: Vc, - pub(super) entry_chunk: Vc>, + pub(super) ident: Vc, pub(super) evaluatable_assets: Vc, pub(super) chunks: Vc, pub(super) source: EcmascriptDevChunkListSource, @@ -39,14 +39,14 @@ impl EcmascriptDevChunkList { #[turbo_tasks::function] pub fn new( chunking_context: Vc, - entry_chunk: Vc>, + ident: Vc, evaluatable_assets: Vc, chunks: Vc, source: Value, ) -> Vc { EcmascriptDevChunkList { chunking_context, - entry_chunk, + ident, evaluatable_assets, chunks, source: source.into_value(), @@ -82,7 +82,7 @@ fn chunk_list_chunk_reference_description() -> Vc { impl OutputAsset for EcmascriptDevChunkList { #[turbo_tasks::function] async fn ident(&self) -> Result> { - let mut ident = self.entry_chunk.ident().await?.clone_value(); + let mut ident = self.ident.await?.clone_value(); for evaluatable_asset in self.evaluatable_assets.await?.iter() { ident.add_asset(Vc::::default(), evaluatable_asset.ident()); } diff --git a/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs b/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs index 20b2b98637693..343e755409091 100644 --- a/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs +++ b/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs @@ -5,8 +5,8 @@ use turbo_tasks_fs::{File, FileSystemPath}; use turbopack_core::{ asset::{Asset, AssetContent}, chunk::{ - availability_info::AvailabilityInfo, Chunk, ChunkItem, ChunkableModule, ChunkableModuleExt, - ChunkingContext, EvaluatableAssets, + availability_info::AvailabilityInfo, Chunk, ChunkItem, ChunkableModule, ChunkingContext, + ChunkingContextExt, EvaluatableAssets, }, ident::AssetIdent, introspect::{ @@ -134,21 +134,21 @@ impl ChunkGroupFilesChunkItem { #[turbo_tasks::function] async fn chunks(self: Vc) -> Result> { let this = self.await?; - let module = this.inner.await?; + let inner = this.inner.await?; let chunks = if let Some(ecma) = - Vc::try_resolve_downcast_type::(module.module).await? + Vc::try_resolve_downcast_type::(inner.module).await? { - module.chunking_context.evaluated_chunk_group( - ecma.as_root_chunk(module.chunking_context), - module + inner.chunking_context.evaluated_chunk_group( + inner.module.ident(), + inner .runtime_entries .unwrap_or_else(EvaluatableAssets::empty) .with_entry(Vc::upcast(ecma)), ) } else { - module + inner .chunking_context - .chunk_group(module.module.as_root_chunk(module.chunking_context)) + .root_chunk_group(Vc::upcast(inner.module)) }; Ok(chunks) } diff --git a/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs b/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs index 05f9612a30f89..efe16e2992716 100644 --- a/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs +++ b/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs @@ -2,10 +2,7 @@ use anyhow::{Context, Result}; use turbo_tasks::{Value, Vc}; use turbopack_core::{ asset::{Asset, AssetContent}, - chunk::{ - availability_info::AvailabilityInfo, Chunk, ChunkableModule, ChunkableModuleExt, - ChunkingContext, - }, + chunk::{availability_info::AvailabilityInfo, ChunkableModule, ChunkingContext}, ident::AssetIdent, module::Module, output::OutputAssets, @@ -52,28 +49,20 @@ impl ManifestChunkAsset { }) } - #[turbo_tasks::function] - pub(super) async fn entry_chunk(self: Vc) -> Result>> { - let this = self.await?; - Ok(this.asset.as_chunk( - Vc::upcast(this.chunking_context), - Value::new(this.availability_info), - )) - } - #[turbo_tasks::function] pub(super) async fn chunks(self: Vc) -> Result> { let this = self.await?; - Ok(this.chunking_context.chunk_group(self.entry_chunk())) + Ok(this + .chunking_context + .chunk_group(Vc::upcast(this.asset), Value::new(this.availability_info))) } #[turbo_tasks::function] pub async fn manifest_chunks(self: Vc) -> Result> { let this = self.await?; - Ok(this.chunking_context.chunk_group(self.as_chunk( - Vc::upcast(this.chunking_context), - Value::new(this.availability_info), - ))) + Ok(this + .chunking_context + .chunk_group(Vc::upcast(self), Value::new(this.availability_info))) } } diff --git a/crates/turbopack-node/src/bootstrap.rs b/crates/turbopack-node/src/bootstrap.rs index 85d876003770a..d99f4ed526f9d 100644 --- a/crates/turbopack-node/src/bootstrap.rs +++ b/crates/turbopack-node/src/bootstrap.rs @@ -5,7 +5,7 @@ use turbo_tasks::Vc; use turbo_tasks_fs::{File, FileSystemPath}; use turbopack_core::{ asset::{Asset, AssetContent}, - chunk::{Chunk, ChunkingContext, EvaluatableAssets}, + chunk::{ChunkingContext, EvaluatableAssets}, ident::AssetIdent, output::{OutputAsset, OutputAssets}, }; @@ -15,7 +15,6 @@ use turbopack_ecmascript::utils::StringifyJs; pub(super) struct NodeJsBootstrapAsset { pub(super) path: Vc, pub(super) chunking_context: Vc>, - pub(super) entry: Vc>, pub(super) evaluatable_assets: Vc, } @@ -27,7 +26,7 @@ fn node_js_bootstrap_chunk_reference_description() -> Vc { impl NodeJsBootstrapAsset { fn chunks(&self) -> Vc { self.chunking_context - .evaluated_chunk_group(self.entry, self.evaluatable_assets) + .evaluated_chunk_group(AssetIdent::from_path(self.path), self.evaluatable_assets) } } diff --git a/crates/turbopack-node/src/evaluate.rs b/crates/turbopack-node/src/evaluate.rs index aa3385af692f3..1dba8de6149b6 100644 --- a/crates/turbopack-node/src/evaluate.rs +++ b/crates/turbopack-node/src/evaluate.rs @@ -22,7 +22,7 @@ use turbo_tasks_fs::{ }; use turbopack_core::{ asset::AssetContent, - chunk::{ChunkableModuleExt, ChunkingContext, EvaluatableAsset, EvaluatableAssets}, + chunk::{ChunkingContext, EvaluatableAsset, EvaluatableAssets}, context::AssetContext, file_source::FileSource, ident::AssetIdent, @@ -174,7 +174,6 @@ pub async fn get_evaluate_pool( NodeJsBootstrapAsset { path, chunking_context, - entry: entry_module.as_root_chunk(chunking_context), evaluatable_assets: runtime_entries.with_entry(entry_module), } .cell(), diff --git a/crates/turbopack-node/src/lib.rs b/crates/turbopack-node/src/lib.rs index 42a753ea5c7f1..00651f71e5a5b 100644 --- a/crates/turbopack-node/src/lib.rs +++ b/crates/turbopack-node/src/lib.rs @@ -17,7 +17,7 @@ use turbo_tasks_env::ProcessEnv; use turbo_tasks_fs::{to_sys_path, File, FileSystemPath}; use turbopack_core::{ asset::{Asset, AssetContent}, - chunk::{ChunkableModuleExt, ChunkingContext, EvaluatableAsset, EvaluatableAssets}, + chunk::{ChunkingContext, EvaluatableAsset, EvaluatableAssets}, module::Module, output::{OutputAsset, OutputAssetsSet}, source_map::GenerateSourceMap, @@ -268,7 +268,6 @@ pub async fn get_intermediate_asset( NodeJsBootstrapAsset { path: chunking_context.chunk_path(main_entry.ident(), ".js".to_string()), chunking_context, - entry: main_entry.as_root_chunk(chunking_context), evaluatable_assets: other_entries.with_entry(main_entry), } .cell(), diff --git a/crates/turbopack-tests/tests/snapshot.rs b/crates/turbopack-tests/tests/snapshot.rs index 9c8da2f1ea4d6..466e62076643d 100644 --- a/crates/turbopack-tests/tests/snapshot.rs +++ b/crates/turbopack-tests/tests/snapshot.rs @@ -30,7 +30,7 @@ use turbopack_build::{BuildChunkingContext, MinifyType}; use turbopack_core::{ asset::Asset, chunk::{ - ChunkableModule, ChunkableModuleExt, ChunkingContext, EvaluatableAssetExt, + ChunkableModule, ChunkingContext, ChunkingContextExt, EvaluatableAssetExt, EvaluatableAssets, }, compile_time_defines, @@ -326,7 +326,7 @@ async fn run_test(resource: String) -> Result> { // TODO: Load runtime entries from snapshots match options.runtime { Runtime::Dev => chunking_context.evaluated_chunk_group( - ecmascript.as_root_chunk(chunking_context), + ecmascript.ident(), runtime_entries .unwrap_or_else(EvaluatableAssets::empty) .with_entry(Vc::upcast(ecmascript)), @@ -359,9 +359,9 @@ async fn run_test(resource: String) -> Result> { } } } else if let Some(chunkable) = - Vc::try_resolve_sidecast::>(entry_module).await? + Vc::try_resolve_downcast::>(entry_module).await? { - chunking_context.chunk_group(chunkable.as_root_chunk(chunking_context)) + chunking_context.root_chunk_group(chunkable) } else { // TODO convert into a serve-able asset bail!("Entry module is not chunkable, so it can't be used to bootstrap the application")