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::{
use turbopack_core::{
asset::AssetContent,
chunk::{
availability_info::AvailabilityInfo, ChunkGroupType, ChunkableModules, ChunkingContext,
ChunkingContextExt, EvaluatableAsset, EvaluatableAssets,
availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
EvaluatableAsset, EvaluatableAssets,
},
file_source::FileSource,
ident::AssetIdent,
module::Module,
module_graph::{GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules},
module_graph::{
chunk_group_info::ChunkGroup, GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules,
},
output::{OutputAsset, OutputAssets},
raw_output::RawOutput,
reference_type::{CssReferenceSubType, ReferenceType},
......@@ -1668,14 +1670,18 @@ impl AppEndpoint {
let server_utils = client_references
.server_utils
.iter()
.map(async |m| Ok(Vc::upcast(*m.await?.module)))
.map(async |m| Ok(ResolvedVc::upcast(m.await?.module)))
.try_join()
.await?;
let chunk_group = chunking_context
.chunk_group_multiple(
.chunk_group(
AssetIdent::from_path(this.app_project.project().project_path())
.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,
Value::new(current_availability_info),
)
......@@ -1710,7 +1716,13 @@ impl AppEndpoint {
let chunk_group = chunking_context
.chunk_group(
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,
Value::new(current_availability_info),
)
......
......@@ -2,6 +2,7 @@ use std::{io::Write, iter::once};
use anyhow::{bail, Context, Result};
use indoc::writedoc;
use once_cell::sync::Lazy;
use turbo_rcstr::RcStr;
use turbo_tasks::{ResolvedVc, Value, ValueToString, Vc};
use turbo_tasks_fs::File;
......@@ -191,6 +192,10 @@ fn ecmascript_client_reference_ssr_ref_modifier() -> Vc<RcStr> {
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]
impl Module for EcmascriptClientReferenceModule {
#[turbo_tasks::function]
......@@ -216,7 +221,7 @@ impl Module for EcmascriptClientReferenceModule {
EcmascriptClientReference::new(
*ResolvedVc::upcast(*client_module),
ChunkGroupType::Evaluated,
Some("client".into()),
Some(ECMASCRIPT_CLIENT_REFERENCE_MERGE_TAG_CLIENT.clone()),
ecmascript_client_reference_client_ref_modifier(),
)
.to_resolved()
......@@ -226,7 +231,7 @@ impl Module for EcmascriptClientReferenceModule {
EcmascriptClientReference::new(
*ResolvedVc::upcast(*ssr_module),
ChunkGroupType::Entry,
Some("ssr".into()),
Some(ECMASCRIPT_CLIENT_REFERENCE_MERGE_TAG_SSR.clone()),
ecmascript_client_reference_ssr_ref_modifier(),
)
.to_resolved()
......
......@@ -9,14 +9,14 @@ use turbopack_core::{
availability_info::AvailabilityInfo,
chunk_group::{make_chunk_group, MakeChunkGroupResult},
module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkableModules, ChunkingConfig,
ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType,
ModuleId, SourceMapsType,
Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
SourceMapsType,
},
environment::Environment,
ident::AssetIdent,
module::Module,
module_graph::ModuleGraph,
module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets},
};
use turbopack_ecmascript::{
......@@ -415,39 +415,23 @@ impl ChunkingContext for BrowserChunkingContext {
}
#[turbo_tasks::function]
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(
async fn chunk_group(
self: ResolvedVc<Self>,
ident: Vc<AssetIdent>,
modules: Vc<ChunkableModules>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Result<Vc<ChunkGroupResult>> {
let span = tracing::info_span!("chunking", ident = ident.to_string().await?.to_string());
async move {
let this = self.await?;
let modules = modules.await?;
let modules = chunk_group.entries();
let input_availability_info = availability_info.into_value();
let MakeChunkGroupResult {
chunks,
availability_info,
} = make_chunk_group(
modules.iter().copied().map(ResolvedVc::upcast),
modules,
module_graph,
ResolvedVc::upcast(self),
input_availability_info,
......
......@@ -8,11 +8,11 @@ use turbo_tasks_hash::DeterministicHash;
use super::{availability_info::AvailabilityInfo, ChunkableModule, EvaluatableAssets};
use crate::{
chunk::{ChunkItem, ChunkType, ChunkableModules, ModuleId},
chunk::{ChunkItem, ChunkType, ModuleId},
environment::Environment,
ident::AssetIdent,
module::Module,
module_graph::ModuleGraph,
module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets},
};
......@@ -184,15 +184,7 @@ pub trait ChunkingContext {
fn chunk_group(
self: Vc<Self>,
ident: Vc<AssetIdent>,
module: Vc<Box<dyn ChunkableModule>>,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Vc<ChunkGroupResult>;
fn chunk_group_multiple(
self: Vc<Self>,
ident: Vc<AssetIdent>,
modules: Vc<ChunkableModules>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Vc<ChunkGroupResult>;
......@@ -235,7 +227,8 @@ pub trait ChunkingContext {
pub trait ChunkingContextExt {
fn root_chunk_group(
self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
) -> Vc<ChunkGroupResult>
where
......@@ -243,7 +236,8 @@ pub trait ChunkingContextExt {
fn root_chunk_group_assets(
self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
) -> Vc<OutputAssets>
where
......@@ -295,7 +289,8 @@ pub trait ChunkingContextExt {
fn chunk_group_assets(
self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Vc<OutputAssets>
......@@ -306,12 +301,13 @@ pub trait ChunkingContextExt {
impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingContextExt for T {
fn root_chunk_group(
self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
) -> Vc<ChunkGroupResult> {
self.chunk_group(
module.ident(),
module,
ident,
chunk_group,
module_graph,
Value::new(AvailabilityInfo::Root),
)
......@@ -319,10 +315,11 @@ impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingConte
fn root_chunk_group_assets(
self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
) -> 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(
......@@ -400,22 +397,30 @@ impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingConte
fn chunk_group_assets(
self: Vc<Self>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> 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]
async fn root_chunk_group_assets(
chunking_context: Vc<Box<dyn ChunkingContext>>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
) -> Result<Vc<OutputAssets>> {
Ok(*chunking_context
.root_chunk_group(module, module_graph)
.root_chunk_group(ident, chunk_group, module_graph)
.await?
.assets)
}
......@@ -460,12 +465,13 @@ async fn entry_chunk_group_asset(
#[turbo_tasks::function]
async fn chunk_group_assets(
chunking_context: Vc<Box<dyn ChunkingContext>>,
module: Vc<Box<dyn ChunkableModule>>,
ident: Vc<AssetIdent>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Result<Vc<OutputAssets>> {
Ok(*chunking_context
.chunk_group(module.ident(), module, module_graph, availability_info)
.chunk_group(ident, chunk_group, module_graph, availability_info)
.await?
.assets)
}
......@@ -4,7 +4,7 @@ use std::{
ops::{Deref, DerefMut},
};
use anyhow::Result;
use anyhow::{bail, Result};
use either::Either;
use indexmap::map::Entry;
use petgraph::graph::{DiGraph, EdgeIndex, NodeIndex};
......@@ -88,11 +88,22 @@ impl Hash for RoaringBitmapWrapper {
pub struct ChunkGroupInfo {
pub module_chunk_groups: FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>,
#[turbo_tasks(trace_ignore)]
pub chunk_groups: Vec<ChunkGroup>,
pub chunk_groups: FxIndexSet<ChunkGroup>,
}
#[turbo_tasks::value(shared)]
#[derive(Debug, Clone, Hash)]
#[turbo_tasks::value_impl]
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 {
/// e.g. a page
Entry {
......
......@@ -10,11 +10,11 @@ use turbo_tasks_hash::{encode_hex, Xxh3Hash64Hasher};
use turbopack_core::{
asset::{Asset, AssetContent},
chunk::{
availability_info::AvailabilityInfo, ChunkableModule, ChunkingContext, ChunkingContextExt,
EvaluatableAssets,
availability_info::AvailabilityInfo, ChunkGroupType, ChunkableModule, ChunkingContext,
ChunkingContextExt, EvaluatableAssets,
},
module::Module,
module_graph::ModuleGraph,
module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets},
version::{Version, VersionedContent},
};
......@@ -162,7 +162,11 @@ impl DevHtmlAsset {
)
} else {
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,
)
};
......
......@@ -9,7 +9,7 @@ use turbopack_core::{
},
ident::AssetIdent,
module::Module,
module_graph::ModuleGraph,
module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::OutputAssets,
};
......@@ -41,7 +41,8 @@ impl AsyncLoaderChunkItem {
}
}
Ok(self.chunking_context.chunk_group_assets(
*ResolvedVc::upcast(module.inner),
module.inner.ident(),
ChunkGroup::Async(ResolvedVc::upcast(module.inner)),
*self.module_graph,
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;
pub mod annotations;
pub mod async_chunk;
pub mod chunk;
pub mod chunk_group_files_asset;
pub mod code_gen;
mod errors;
pub mod magic_identifier;
......
......@@ -8,7 +8,7 @@ use turbopack_core::{
},
ident::AssetIdent,
module::Module,
module_graph::ModuleGraph,
module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::OutputAssets,
reference::{ModuleReferences, SingleOutputAssetReference},
};
......@@ -60,14 +60,15 @@ impl ManifestAsyncModule {
#[turbo_tasks::function]
pub(super) fn chunks(&self) -> Vc<OutputAssets> {
self.chunking_context.chunk_group_assets(
*ResolvedVc::upcast(self.inner),
self.inner.ident(),
ChunkGroup::Async(ResolvedVc::upcast(self.inner)),
*self.module_graph,
Value::new(self.availability_info),
)
}
#[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?;
if let Some(chunk_items) = this.availability_info.available_modules() {
if *chunk_items.get(*this.inner).await? {
......@@ -75,7 +76,8 @@ impl ManifestAsyncModule {
}
}
Ok(this.chunking_context.chunk_group_assets(
Vc::upcast(self),
self.ident(),
ChunkGroup::Async(ResolvedVc::upcast(self)),
*this.module_graph,
Value::new(this.availability_info),
))
......
......@@ -11,14 +11,14 @@ use turbopack_core::{
availability_info::AvailabilityInfo,
chunk_group::{make_chunk_group, MakeChunkGroupResult},
module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkableModules, ChunkingConfig,
ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType,
ModuleId, SourceMapsType,
Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
SourceMapsType,
},
environment::Environment,
ident::AssetIdent,
module::Module,
module_graph::ModuleGraph,
module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
output::{OutputAsset, OutputAssets},
};
use turbopack_ecmascript::{
......@@ -339,37 +339,21 @@ impl ChunkingContext for NodeJsChunkingContext {
}
#[turbo_tasks::function]
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(
async fn chunk_group(
self: ResolvedVc<Self>,
ident: Vc<AssetIdent>,
modules: Vc<ChunkableModules>,
chunk_group: ChunkGroup,
module_graph: Vc<ModuleGraph>,
availability_info: Value<AvailabilityInfo>,
) -> Result<Vc<ChunkGroupResult>> {
let span = tracing::info_span!("chunking", module = ident.to_string().await?.to_string());
async move {
let modules = modules.await?;
let modules = chunk_group.entries();
let MakeChunkGroupResult {
chunks,
availability_info,
} = make_chunk_group(
modules.iter().copied().map(ResolvedVc::upcast),
modules,
module_graph,
ResolvedVc::upcast(self),
availability_info.into_value(),
......
......@@ -33,8 +33,8 @@ use turbopack_browser::BrowserChunkingContext;
use turbopack_core::{
asset::Asset,
chunk::{
availability_info::AvailabilityInfo, ChunkGroupType, ChunkableModule, ChunkingContext,
ChunkingContextExt, EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets, MinifyType,
availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets, MinifyType,
},
compile_time_defines,
compile_time_info::CompileTimeInfo,
......@@ -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 {
// TODO convert into a serve-able asset
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