Unverified Commit 801e06ff authored by Niklas Mischkulnig's avatar Niklas Mischkulnig Committed by GitHub

Turbopack: accept ChunkGroup in chunking context (#76242)

<!-- Thanks for opening a PR! Your contribution is much appreciated.
To make sure your PR is handled as smoothly as possible we request that you follow the checklist sections below.
Choose the right checklist for the change(s) that you're making:

## For Contributors

### Improving Documentation

- Run `pnpm prettier-fix` to fix formatting issues before opening the PR.
- Read the Docs Contribution Guide to ensure your contribution follows the docs guidelines: https://nextjs.org/docs/community/contribution-guide

### Adding or Updating Examples

- The "examples guidelines" are followed from our contributing doc https://github.com/vercel/next.js/blob/canary/contributing/examples/adding-examples.md
- Make sure the linting passes by running `pnpm build && pnpm lint`. See https://github.com/vercel/next.js/blob/canary/contributing/repository/linting.md

### Fixing a bug

- Related issues linked using `fixes #number`
- Tests added. See: https://github.com/vercel/next.js/blob/canary/contributing/core/testing.md#writing-tests-for-nextjs
- Errors have a helpful link attached, see https://github.com/vercel/next.js/blob/canary/contributing.md

### Adding a feature

- Implements an existing feature request or RFC. Make sure the feature request has been accepted for implementation before opening a PR. (A discussion must be opened, see https://github.com/vercel/next.js/discussions/new?category=ideas)
- Related issues/discussions are linked using `fixes #number`
- e2e tests added (https://github.com/vercel/next.js/blob/canary/contributing/core/testing.md#writing-tests-for-nextjs)
- Documentation added
- Telemetry added. In case of a feature if it's used or not.
- Errors have a helpful link attached, see https://github.com/vercel/next.js/blob/canary/contributing.md


## For Maintainers

- Minimal description (aim for explaining to someone not on the team to understand the PR)
- When linking to a Slack thread, you might want to share details of the conclusion
- Link both the Linear (Fixes NEXT-xxx) and the GitHub issues
- Add review comments if necessary to explain to the reviewer the logic behind a change

### What?

### Why?

### How?

Closes NEXT-
Fixes #

-->
parent 8624a4c1
...@@ -53,13 +53,15 @@ use turbopack::{ ...@@ -53,13 +53,15 @@ use turbopack::{
use turbopack_core::{ use turbopack_core::{
asset::AssetContent, asset::AssetContent,
chunk::{ chunk::{
availability_info::AvailabilityInfo, ChunkGroupType, ChunkableModules, ChunkingContext, availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
ChunkingContextExt, EvaluatableAsset, EvaluatableAssets, EvaluatableAsset, EvaluatableAssets,
}, },
file_source::FileSource, file_source::FileSource,
ident::AssetIdent, ident::AssetIdent,
module::Module, module::Module,
module_graph::{GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules}, module_graph::{
chunk_group_info::ChunkGroup, GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules,
},
output::{OutputAsset, OutputAssets}, output::{OutputAsset, OutputAssets},
raw_output::RawOutput, raw_output::RawOutput,
reference_type::{CssReferenceSubType, ReferenceType}, reference_type::{CssReferenceSubType, ReferenceType},
...@@ -1668,14 +1670,18 @@ impl AppEndpoint { ...@@ -1668,14 +1670,18 @@ impl AppEndpoint {
let server_utils = client_references let server_utils = client_references
.server_utils .server_utils
.iter() .iter()
.map(async |m| Ok(Vc::upcast(*m.await?.module))) .map(async |m| Ok(ResolvedVc::upcast(m.await?.module)))
.try_join() .try_join()
.await?; .await?;
let chunk_group = chunking_context let chunk_group = chunking_context
.chunk_group_multiple( .chunk_group(
AssetIdent::from_path(this.app_project.project().project_path()) AssetIdent::from_path(this.app_project.project().project_path())
.with_modifier(server_utils_modifier()), .with_modifier(server_utils_modifier()),
ChunkableModules::interned(server_utils), // TODO this should be ChunkGroup::Shared
ChunkGroup::Entry {
entries: server_utils,
ty: ChunkGroupType::Entry,
},
module_graph, module_graph,
Value::new(current_availability_info), Value::new(current_availability_info),
) )
...@@ -1710,7 +1716,13 @@ impl AppEndpoint { ...@@ -1710,7 +1716,13 @@ impl AppEndpoint {
let chunk_group = chunking_context let chunk_group = chunking_context
.chunk_group( .chunk_group(
server_component.ident(), server_component.ident(),
Vc::upcast(*server_component.await?.module), // TODO this should be ChunkGroup::Shared
ChunkGroup::Entry {
entries: vec![ResolvedVc::upcast(
server_component.await?.module,
)],
ty: ChunkGroupType::Entry,
},
module_graph, module_graph,
Value::new(current_availability_info), Value::new(current_availability_info),
) )
......
...@@ -2,6 +2,7 @@ use std::{io::Write, iter::once}; ...@@ -2,6 +2,7 @@ use std::{io::Write, iter::once};
use anyhow::{bail, Context, Result}; use anyhow::{bail, Context, Result};
use indoc::writedoc; use indoc::writedoc;
use once_cell::sync::Lazy;
use turbo_rcstr::RcStr; use turbo_rcstr::RcStr;
use turbo_tasks::{ResolvedVc, Value, ValueToString, Vc}; use turbo_tasks::{ResolvedVc, Value, ValueToString, Vc};
use turbo_tasks_fs::File; use turbo_tasks_fs::File;
...@@ -191,6 +192,10 @@ fn ecmascript_client_reference_ssr_ref_modifier() -> Vc<RcStr> { ...@@ -191,6 +192,10 @@ fn ecmascript_client_reference_ssr_ref_modifier() -> Vc<RcStr> {
Vc::cell("ecmascript client reference to ssr".into()) Vc::cell("ecmascript client reference to ssr".into())
} }
pub static ECMASCRIPT_CLIENT_REFERENCE_MERGE_TAG_CLIENT: Lazy<RcStr> =
Lazy::new(|| "client".into());
pub static ECMASCRIPT_CLIENT_REFERENCE_MERGE_TAG_SSR: Lazy<RcStr> = Lazy::new(|| "ssr".into());
#[turbo_tasks::value_impl] #[turbo_tasks::value_impl]
impl Module for EcmascriptClientReferenceModule { impl Module for EcmascriptClientReferenceModule {
#[turbo_tasks::function] #[turbo_tasks::function]
...@@ -216,7 +221,7 @@ impl Module for EcmascriptClientReferenceModule { ...@@ -216,7 +221,7 @@ impl Module for EcmascriptClientReferenceModule {
EcmascriptClientReference::new( EcmascriptClientReference::new(
*ResolvedVc::upcast(*client_module), *ResolvedVc::upcast(*client_module),
ChunkGroupType::Evaluated, ChunkGroupType::Evaluated,
Some("client".into()), Some(ECMASCRIPT_CLIENT_REFERENCE_MERGE_TAG_CLIENT.clone()),
ecmascript_client_reference_client_ref_modifier(), ecmascript_client_reference_client_ref_modifier(),
) )
.to_resolved() .to_resolved()
...@@ -226,7 +231,7 @@ impl Module for EcmascriptClientReferenceModule { ...@@ -226,7 +231,7 @@ impl Module for EcmascriptClientReferenceModule {
EcmascriptClientReference::new( EcmascriptClientReference::new(
*ResolvedVc::upcast(*ssr_module), *ResolvedVc::upcast(*ssr_module),
ChunkGroupType::Entry, ChunkGroupType::Entry,
Some("ssr".into()), Some(ECMASCRIPT_CLIENT_REFERENCE_MERGE_TAG_SSR.clone()),
ecmascript_client_reference_ssr_ref_modifier(), ecmascript_client_reference_ssr_ref_modifier(),
) )
.to_resolved() .to_resolved()
......
...@@ -9,14 +9,14 @@ use turbopack_core::{ ...@@ -9,14 +9,14 @@ use turbopack_core::{
availability_info::AvailabilityInfo, availability_info::AvailabilityInfo,
chunk_group::{make_chunk_group, MakeChunkGroupResult}, chunk_group::{make_chunk_group, MakeChunkGroupResult},
module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy}, module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkableModules, ChunkingConfig, Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
ModuleId, SourceMapsType, SourceMapsType,
}, },
environment::Environment, environment::Environment,
ident::AssetIdent, ident::AssetIdent,
module::Module, module::Module,
module_graph::ModuleGraph, module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets}, output::{OutputAsset, OutputAssets},
}; };
use turbopack_ecmascript::{ use turbopack_ecmascript::{
...@@ -415,39 +415,23 @@ impl ChunkingContext for BrowserChunkingContext { ...@@ -415,39 +415,23 @@ impl ChunkingContext for BrowserChunkingContext {
} }
#[turbo_tasks::function] #[turbo_tasks::function]
fn chunk_group( async fn chunk_group(
self: Vc<Self>,
ident: Vc<AssetIdent>,
module: ResolvedVc<Box<dyn ChunkableModule>>,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Vc<ChunkGroupResult> {
self.chunk_group_multiple(
ident,
Vc::cell(vec![module]),
module_graph,
availability_info,
)
}
#[turbo_tasks::function]
async fn chunk_group_multiple(
self: ResolvedVc<Self>, self: ResolvedVc<Self>,
ident: Vc<AssetIdent>, ident: Vc<AssetIdent>,
modules: Vc<ChunkableModules>, chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>, availability_info: Value<AvailabilityInfo>,
) -> Result<Vc<ChunkGroupResult>> { ) -> Result<Vc<ChunkGroupResult>> {
let span = tracing::info_span!("chunking", ident = ident.to_string().await?.to_string()); let span = tracing::info_span!("chunking", ident = ident.to_string().await?.to_string());
async move { async move {
let this = self.await?; let this = self.await?;
let modules = modules.await?; let modules = chunk_group.entries();
let input_availability_info = availability_info.into_value(); let input_availability_info = availability_info.into_value();
let MakeChunkGroupResult { let MakeChunkGroupResult {
chunks, chunks,
availability_info, availability_info,
} = make_chunk_group( } = make_chunk_group(
modules.iter().copied().map(ResolvedVc::upcast), modules,
module_graph, module_graph,
ResolvedVc::upcast(self), ResolvedVc::upcast(self),
input_availability_info, input_availability_info,
......
...@@ -8,11 +8,11 @@ use turbo_tasks_hash::DeterministicHash; ...@@ -8,11 +8,11 @@ use turbo_tasks_hash::DeterministicHash;
use super::{availability_info::AvailabilityInfo, ChunkableModule, EvaluatableAssets}; use super::{availability_info::AvailabilityInfo, ChunkableModule, EvaluatableAssets};
use crate::{ use crate::{
chunk::{ChunkItem, ChunkType, ChunkableModules, ModuleId}, chunk::{ChunkItem, ChunkType, ModuleId},
environment::Environment, environment::Environment,
ident::AssetIdent, ident::AssetIdent,
module::Module, module::Module,
module_graph::ModuleGraph, module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets}, output::{OutputAsset, OutputAssets},
}; };
...@@ -184,15 +184,7 @@ pub trait ChunkingContext { ...@@ -184,15 +184,7 @@ pub trait ChunkingContext {
fn chunk_group( fn chunk_group(
self: Vc<Self>, self: Vc<Self>,
ident: Vc<AssetIdent>, ident: Vc<AssetIdent>,
module: Vc<Box<dyn ChunkableModule>>, chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Vc<ChunkGroupResult>;
fn chunk_group_multiple(
self: Vc<Self>,
ident: Vc<AssetIdent>,
modules: Vc<ChunkableModules>,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>, availability_info: Value<AvailabilityInfo>,
) -> Vc<ChunkGroupResult>; ) -> Vc<ChunkGroupResult>;
...@@ -235,7 +227,8 @@ pub trait ChunkingContext { ...@@ -235,7 +227,8 @@ pub trait ChunkingContext {
pub trait ChunkingContextExt { pub trait ChunkingContextExt {
fn root_chunk_group( fn root_chunk_group(
self: Vc<Self>, self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
) -> Vc<ChunkGroupResult> ) -> Vc<ChunkGroupResult>
where where
...@@ -243,7 +236,8 @@ pub trait ChunkingContextExt { ...@@ -243,7 +236,8 @@ pub trait ChunkingContextExt {
fn root_chunk_group_assets( fn root_chunk_group_assets(
self: Vc<Self>, self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
) -> Vc<OutputAssets> ) -> Vc<OutputAssets>
where where
...@@ -295,7 +289,8 @@ pub trait ChunkingContextExt { ...@@ -295,7 +289,8 @@ pub trait ChunkingContextExt {
fn chunk_group_assets( fn chunk_group_assets(
self: Vc<Self>, self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>, availability_info: Value<AvailabilityInfo>,
) -> Vc<OutputAssets> ) -> Vc<OutputAssets>
...@@ -306,12 +301,13 @@ pub trait ChunkingContextExt { ...@@ -306,12 +301,13 @@ pub trait ChunkingContextExt {
impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingContextExt for T { impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingContextExt for T {
fn root_chunk_group( fn root_chunk_group(
self: Vc<Self>, self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
) -> Vc<ChunkGroupResult> { ) -> Vc<ChunkGroupResult> {
self.chunk_group( self.chunk_group(
module.ident(), ident,
module, chunk_group,
module_graph, module_graph,
Value::new(AvailabilityInfo::Root), Value::new(AvailabilityInfo::Root),
) )
...@@ -319,10 +315,11 @@ impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingConte ...@@ -319,10 +315,11 @@ impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingConte
fn root_chunk_group_assets( fn root_chunk_group_assets(
self: Vc<Self>, self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
) -> Vc<OutputAssets> { ) -> Vc<OutputAssets> {
root_chunk_group_assets(Vc::upcast(self), module, module_graph) root_chunk_group_assets(Vc::upcast(self), ident, chunk_group, module_graph)
} }
fn evaluated_chunk_group_assets( fn evaluated_chunk_group_assets(
...@@ -400,22 +397,30 @@ impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingConte ...@@ -400,22 +397,30 @@ impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingConte
fn chunk_group_assets( fn chunk_group_assets(
self: Vc<Self>, self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>, availability_info: Value<AvailabilityInfo>,
) -> Vc<OutputAssets> { ) -> Vc<OutputAssets> {
chunk_group_assets(Vc::upcast(self), module, module_graph, availability_info) chunk_group_assets(
Vc::upcast(self),
ident,
chunk_group,
module_graph,
availability_info,
)
} }
} }
#[turbo_tasks::function] #[turbo_tasks::function]
async fn root_chunk_group_assets( async fn root_chunk_group_assets(
chunking_context: Vc<Box<dyn ChunkingContext>>, chunking_context: Vc<Box<dyn ChunkingContext>>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
) -> Result<Vc<OutputAssets>> { ) -> Result<Vc<OutputAssets>> {
Ok(*chunking_context Ok(*chunking_context
.root_chunk_group(module, module_graph) .root_chunk_group(ident, chunk_group, module_graph)
.await? .await?
.assets) .assets)
} }
...@@ -460,12 +465,13 @@ async fn entry_chunk_group_asset( ...@@ -460,12 +465,13 @@ async fn entry_chunk_group_asset(
#[turbo_tasks::function] #[turbo_tasks::function]
async fn chunk_group_assets( async fn chunk_group_assets(
chunking_context: Vc<Box<dyn ChunkingContext>>, chunking_context: Vc<Box<dyn ChunkingContext>>,
module: Vc<Box<dyn ChunkableModule>>, ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>, availability_info: Value<AvailabilityInfo>,
) -> Result<Vc<OutputAssets>> { ) -> Result<Vc<OutputAssets>> {
Ok(*chunking_context Ok(*chunking_context
.chunk_group(module.ident(), module, module_graph, availability_info) .chunk_group(ident, chunk_group, module_graph, availability_info)
.await? .await?
.assets) .assets)
} }
...@@ -4,7 +4,7 @@ use std::{ ...@@ -4,7 +4,7 @@ use std::{
ops::{Deref, DerefMut}, ops::{Deref, DerefMut},
}; };
use anyhow::Result; use anyhow::{bail, Result};
use either::Either; use either::Either;
use indexmap::map::Entry; use indexmap::map::Entry;
use petgraph::graph::{DiGraph, EdgeIndex, NodeIndex}; use petgraph::graph::{DiGraph, EdgeIndex, NodeIndex};
...@@ -88,11 +88,22 @@ impl Hash for RoaringBitmapWrapper { ...@@ -88,11 +88,22 @@ impl Hash for RoaringBitmapWrapper {
pub struct ChunkGroupInfo { pub struct ChunkGroupInfo {
pub module_chunk_groups: FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>, pub module_chunk_groups: FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>,
#[turbo_tasks(trace_ignore)] #[turbo_tasks(trace_ignore)]
pub chunk_groups: Vec<ChunkGroup>, pub chunk_groups: FxIndexSet<ChunkGroup>,
} }
#[turbo_tasks::value(shared)] #[turbo_tasks::value_impl]
#[derive(Debug, Clone, Hash)] impl ChunkGroupInfo {
#[turbo_tasks::function]
pub fn get_index_of(&self, chunk_group: ChunkGroup) -> Result<Vc<usize>> {
if let Some(idx) = self.chunk_groups.get_index_of(&chunk_group) {
Ok(Vc::cell(idx))
} else {
bail!("Couldn't find chunk group index");
}
}
}
#[derive(Debug, Clone, Hash, TaskInput, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChunkGroup { pub enum ChunkGroup {
/// e.g. a page /// e.g. a page
Entry { Entry {
......
...@@ -10,11 +10,11 @@ use turbo_tasks_hash::{encode_hex, Xxh3Hash64Hasher}; ...@@ -10,11 +10,11 @@ use turbo_tasks_hash::{encode_hex, Xxh3Hash64Hasher};
use turbopack_core::{ use turbopack_core::{
asset::{Asset, AssetContent}, asset::{Asset, AssetContent},
chunk::{ chunk::{
availability_info::AvailabilityInfo, ChunkableModule, ChunkingContext, ChunkingContextExt, availability_info::AvailabilityInfo, ChunkGroupType, ChunkableModule, ChunkingContext,
EvaluatableAssets, ChunkingContextExt, EvaluatableAssets,
}, },
module::Module, module::Module,
module_graph::ModuleGraph, module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets}, output::{OutputAsset, OutputAssets},
version::{Version, VersionedContent}, version::{Version, VersionedContent},
}; };
...@@ -162,7 +162,11 @@ impl DevHtmlAsset { ...@@ -162,7 +162,11 @@ impl DevHtmlAsset {
) )
} else { } else {
chunking_context.root_chunk_group_assets( chunking_context.root_chunk_group_assets(
*ResolvedVc::upcast(chunkable_module), chunkable_module.ident(),
ChunkGroup::Entry {
entries: vec![ResolvedVc::upcast(chunkable_module)],
ty: ChunkGroupType::Evaluated,
},
*module_graph, *module_graph,
) )
}; };
......
...@@ -9,7 +9,7 @@ use turbopack_core::{ ...@@ -9,7 +9,7 @@ use turbopack_core::{
}, },
ident::AssetIdent, ident::AssetIdent,
module::Module, module::Module,
module_graph::ModuleGraph, module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::OutputAssets, output::OutputAssets,
}; };
...@@ -41,7 +41,8 @@ impl AsyncLoaderChunkItem { ...@@ -41,7 +41,8 @@ impl AsyncLoaderChunkItem {
} }
} }
Ok(self.chunking_context.chunk_group_assets( Ok(self.chunking_context.chunk_group_assets(
*ResolvedVc::upcast(module.inner), module.inner.ident(),
ChunkGroup::Async(ResolvedVc::upcast(module.inner)),
*self.module_graph, *self.module_graph,
Value::new(module.availability_info), Value::new(module.availability_info),
)) ))
......
use anyhow::Result;
use turbo_rcstr::RcStr;
use turbo_tasks::{FxIndexSet, ResolvedVc, TryJoinIterExt, Value, ValueToString, Vc};
use turbo_tasks_fs::{File, FileSystemPath};
use turbopack_core::{
asset::{Asset, AssetContent},
chunk::{
availability_info::AvailabilityInfo, ChunkItem, ChunkType, ChunkableModule,
ChunkingContext, ChunkingContextExt, EvaluatableAsset, EvaluatableAssets,
},
ident::AssetIdent,
introspect::{
module::IntrospectableModule, utils::content_to_details, Introspectable,
IntrospectableChildren,
},
module::Module,
module_graph::ModuleGraph,
output::{OutputAsset, OutputAssets},
reference::{ModuleReference, ModuleReferences, SingleModuleReference},
};
use crate::{
chunk::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
EcmascriptChunkType, EcmascriptExports,
},
runtime_functions::TURBOPACK_EXPORT_VALUE,
utils::StringifyJs,
};
#[turbo_tasks::function]
fn modifier() -> Vc<RcStr> {
Vc::cell("chunk group files".into())
}
/// An asset that exports a list of chunk URLs by putting the [asset] into a
/// ChunkGroup with the provided ChunkingContext.
#[turbo_tasks::value(shared)]
pub struct ChunkGroupFilesAsset {
pub module: ResolvedVc<Box<dyn ChunkableModule>>,
pub client_root: ResolvedVc<FileSystemPath>,
pub chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
pub runtime_entries: Option<ResolvedVc<EvaluatableAssets>>,
}
#[turbo_tasks::function]
fn module_description() -> Vc<RcStr> {
Vc::cell("module".into())
}
#[turbo_tasks::function]
fn runtime_entry_description() -> Vc<RcStr> {
Vc::cell("runtime entry".into())
}
#[turbo_tasks::value_impl]
impl Module for ChunkGroupFilesAsset {
#[turbo_tasks::function]
fn ident(&self) -> Vc<AssetIdent> {
self.module.ident().with_modifier(modifier())
}
#[turbo_tasks::function]
async fn references(&self) -> Result<Vc<ModuleReferences>> {
let mut references: Vec<ResolvedVc<Box<dyn ModuleReference>>> = vec![ResolvedVc::upcast(
SingleModuleReference::new(*ResolvedVc::upcast(self.module), module_description())
.to_resolved()
.await?,
)];
if let Some(runtime_entries) = self.runtime_entries {
references.extend(
runtime_entries
.await?
.iter()
.map(|&entry| async move {
Ok(ResolvedVc::upcast(
SingleModuleReference::new(
Vc::upcast(*entry),
runtime_entry_description(),
)
.to_resolved()
.await?,
))
})
.try_join()
.await?,
);
}
Ok(Vc::cell(references))
}
}
#[turbo_tasks::value_impl]
impl Asset for ChunkGroupFilesAsset {
#[turbo_tasks::function]
fn content(&self) -> Vc<AssetContent> {
AssetContent::file(File::from(RcStr::from("// Chunking only content")).into())
}
}
#[turbo_tasks::value_impl]
impl ChunkableModule for ChunkGroupFilesAsset {
#[turbo_tasks::function]
async fn as_chunk_item(
self: ResolvedVc<Self>,
module_graph: ResolvedVc<ModuleGraph>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
) -> Result<Vc<Box<dyn turbopack_core::chunk::ChunkItem>>> {
let this = self.await?;
Ok(Vc::upcast(
ChunkGroupFilesChunkItem {
module_graph,
chunking_context,
client_root: this.client_root,
inner: self,
}
.cell(),
))
}
}
#[turbo_tasks::value_impl]
impl EcmascriptChunkPlaceable for ChunkGroupFilesAsset {
#[turbo_tasks::function]
fn get_exports(&self) -> Vc<EcmascriptExports> {
EcmascriptExports::Value.cell()
}
}
#[turbo_tasks::value]
struct ChunkGroupFilesChunkItem {
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
module_graph: ResolvedVc<ModuleGraph>,
client_root: ResolvedVc<FileSystemPath>,
inner: ResolvedVc<ChunkGroupFilesAsset>,
}
#[turbo_tasks::value_impl]
impl ChunkGroupFilesChunkItem {
#[turbo_tasks::function]
async fn chunks(&self) -> Result<Vc<OutputAssets>> {
let inner = self.inner.await?;
let chunks = if let Some(ecma) =
ResolvedVc::try_sidecast::<Box<dyn EvaluatableAsset>>(inner.module)
{
inner.chunking_context.evaluated_chunk_group_assets(
inner.module.ident(),
inner
.runtime_entries
.as_deref()
.copied()
.unwrap_or_else(EvaluatableAssets::empty)
.with_entry(*ecma),
*self.module_graph,
Value::new(AvailabilityInfo::Root),
)
} else {
inner
.chunking_context
.root_chunk_group_assets(*ResolvedVc::upcast(inner.module), *self.module_graph)
};
Ok(chunks)
}
}
#[turbo_tasks::value_impl]
impl EcmascriptChunkItem for ChunkGroupFilesChunkItem {
#[turbo_tasks::function]
async fn content(self: Vc<Self>) -> Result<Vc<EcmascriptChunkItemContent>> {
let chunks = self.chunks();
let this = self.await?;
let module = this.inner.await?;
let client_root = module.client_root.await?;
let chunks_paths = chunks
.await?
.iter()
.map(|chunk| chunk.path())
.try_join()
.await?;
let chunks_paths: Vec<_> = chunks_paths
.iter()
.filter_map(|path| client_root.get_path_to(path))
.collect();
Ok(EcmascriptChunkItemContent {
inner_code: format!(
"{TURBOPACK_EXPORT_VALUE}({:#});\n",
StringifyJs(&chunks_paths)
)
.into(),
..Default::default()
}
.cell())
}
}
#[turbo_tasks::function]
fn chunk_group_chunk_reference_description() -> Vc<RcStr> {
Vc::cell("chunk group chunk".into())
}
#[turbo_tasks::value_impl]
impl ChunkItem for ChunkGroupFilesChunkItem {
#[turbo_tasks::function]
fn asset_ident(&self) -> Vc<AssetIdent> {
self.inner.ident()
}
#[turbo_tasks::function]
fn references(self: Vc<Self>) -> Vc<OutputAssets> {
self.chunks()
}
#[turbo_tasks::function]
fn chunking_context(&self) -> Vc<Box<dyn ChunkingContext>> {
*ResolvedVc::upcast(self.chunking_context)
}
#[turbo_tasks::function]
async fn ty(&self) -> Result<Vc<Box<dyn ChunkType>>> {
Ok(Vc::upcast(
Vc::<EcmascriptChunkType>::default().resolve().await?,
))
}
#[turbo_tasks::function]
fn module(&self) -> Vc<Box<dyn Module>> {
*ResolvedVc::upcast(self.inner)
}
}
#[turbo_tasks::value_impl]
impl Introspectable for ChunkGroupFilesAsset {
#[turbo_tasks::function]
fn ty(&self) -> Vc<RcStr> {
Vc::cell("chunk group files asset".into())
}
#[turbo_tasks::function]
fn details(self: Vc<Self>) -> Vc<RcStr> {
content_to_details(self.content())
}
#[turbo_tasks::function]
fn title(self: Vc<Self>) -> Vc<RcStr> {
self.ident().to_string()
}
#[turbo_tasks::function]
async fn children(&self) -> Result<Vc<IntrospectableChildren>> {
let mut children = FxIndexSet::default();
children.insert((
ResolvedVc::cell("inner asset".into()),
IntrospectableModule::new(*ResolvedVc::upcast(self.module))
.to_resolved()
.await?,
));
Ok(Vc::cell(children))
}
}
...@@ -12,7 +12,6 @@ pub mod analyzer; ...@@ -12,7 +12,6 @@ pub mod analyzer;
pub mod annotations; pub mod annotations;
pub mod async_chunk; pub mod async_chunk;
pub mod chunk; pub mod chunk;
pub mod chunk_group_files_asset;
pub mod code_gen; pub mod code_gen;
mod errors; mod errors;
pub mod magic_identifier; pub mod magic_identifier;
......
...@@ -8,7 +8,7 @@ use turbopack_core::{ ...@@ -8,7 +8,7 @@ use turbopack_core::{
}, },
ident::AssetIdent, ident::AssetIdent,
module::Module, module::Module,
module_graph::ModuleGraph, module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::OutputAssets, output::OutputAssets,
reference::{ModuleReferences, SingleOutputAssetReference}, reference::{ModuleReferences, SingleOutputAssetReference},
}; };
...@@ -60,14 +60,15 @@ impl ManifestAsyncModule { ...@@ -60,14 +60,15 @@ impl ManifestAsyncModule {
#[turbo_tasks::function] #[turbo_tasks::function]
pub(super) fn chunks(&self) -> Vc<OutputAssets> { pub(super) fn chunks(&self) -> Vc<OutputAssets> {
self.chunking_context.chunk_group_assets( self.chunking_context.chunk_group_assets(
*ResolvedVc::upcast(self.inner), self.inner.ident(),
ChunkGroup::Async(ResolvedVc::upcast(self.inner)),
*self.module_graph, *self.module_graph,
Value::new(self.availability_info), Value::new(self.availability_info),
) )
} }
#[turbo_tasks::function] #[turbo_tasks::function]
pub async fn manifest_chunks(self: Vc<Self>) -> Result<Vc<OutputAssets>> { pub async fn manifest_chunks(self: ResolvedVc<Self>) -> Result<Vc<OutputAssets>> {
let this = self.await?; let this = self.await?;
if let Some(chunk_items) = this.availability_info.available_modules() { if let Some(chunk_items) = this.availability_info.available_modules() {
if *chunk_items.get(*this.inner).await? { if *chunk_items.get(*this.inner).await? {
...@@ -75,7 +76,8 @@ impl ManifestAsyncModule { ...@@ -75,7 +76,8 @@ impl ManifestAsyncModule {
} }
} }
Ok(this.chunking_context.chunk_group_assets( Ok(this.chunking_context.chunk_group_assets(
Vc::upcast(self), self.ident(),
ChunkGroup::Async(ResolvedVc::upcast(self)),
*this.module_graph, *this.module_graph,
Value::new(this.availability_info), Value::new(this.availability_info),
)) ))
......
...@@ -11,14 +11,14 @@ use turbopack_core::{ ...@@ -11,14 +11,14 @@ use turbopack_core::{
availability_info::AvailabilityInfo, availability_info::AvailabilityInfo,
chunk_group::{make_chunk_group, MakeChunkGroupResult}, chunk_group::{make_chunk_group, MakeChunkGroupResult},
module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy}, module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkableModules, ChunkingConfig, Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
ModuleId, SourceMapsType, SourceMapsType,
}, },
environment::Environment, environment::Environment,
ident::AssetIdent, ident::AssetIdent,
module::Module, module::Module,
module_graph::ModuleGraph, module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets}, output::{OutputAsset, OutputAssets},
}; };
use turbopack_ecmascript::{ use turbopack_ecmascript::{
...@@ -339,37 +339,21 @@ impl ChunkingContext for NodeJsChunkingContext { ...@@ -339,37 +339,21 @@ impl ChunkingContext for NodeJsChunkingContext {
} }
#[turbo_tasks::function] #[turbo_tasks::function]
fn chunk_group( async fn chunk_group(
self: Vc<Self>,
ident: Vc<AssetIdent>,
module: ResolvedVc<Box<dyn ChunkableModule>>,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Vc<ChunkGroupResult> {
self.chunk_group_multiple(
ident,
Vc::cell(vec![module]),
module_graph,
availability_info,
)
}
#[turbo_tasks::function]
async fn chunk_group_multiple(
self: ResolvedVc<Self>, self: ResolvedVc<Self>,
ident: Vc<AssetIdent>, ident: Vc<AssetIdent>,
modules: Vc<ChunkableModules>, chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>, availability_info: Value<AvailabilityInfo>,
) -> Result<Vc<ChunkGroupResult>> { ) -> Result<Vc<ChunkGroupResult>> {
let span = tracing::info_span!("chunking", module = ident.to_string().await?.to_string()); let span = tracing::info_span!("chunking", module = ident.to_string().await?.to_string());
async move { async move {
let modules = modules.await?; let modules = chunk_group.entries();
let MakeChunkGroupResult { let MakeChunkGroupResult {
chunks, chunks,
availability_info, availability_info,
} = make_chunk_group( } = make_chunk_group(
modules.iter().copied().map(ResolvedVc::upcast), modules,
module_graph, module_graph,
ResolvedVc::upcast(self), ResolvedVc::upcast(self),
availability_info.into_value(), availability_info.into_value(),
......
...@@ -33,8 +33,8 @@ use turbopack_browser::BrowserChunkingContext; ...@@ -33,8 +33,8 @@ use turbopack_browser::BrowserChunkingContext;
use turbopack_core::{ use turbopack_core::{
asset::Asset, asset::Asset,
chunk::{ chunk::{
availability_info::AvailabilityInfo, ChunkGroupType, ChunkableModule, ChunkingContext, availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
ChunkingContextExt, EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets, MinifyType, EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets, MinifyType,
}, },
compile_time_defines, compile_time_defines,
compile_time_info::CompileTimeInfo, compile_time_info::CompileTimeInfo,
...@@ -442,11 +442,6 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> { ...@@ -442,11 +442,6 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
]) ])
} }
} }
} else if let Some(chunkable) =
Vc::try_resolve_downcast::<Box<dyn ChunkableModule>>(entry_module).await?
{
let module_graph = ModuleGraph::from_module(Vc::upcast(chunkable), ChunkGroupType::Entry);
chunking_context.root_chunk_group_assets(chunkable, module_graph)
} else { } else {
// TODO convert into a serve-able asset // TODO convert into a serve-able asset
bail!("Entry module is not chunkable, so it can't be used to bootstrap the application") bail!("Entry module is not chunkable, so it can't be used to bootstrap the application")
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment