remove ChunkingType::Separate (vercel/turborepo#5419)

### Description

We don't need that.
That simplifies code

Also renames SeparateAsync to Async to simplify the name a bit

### Testing Instructions

CI

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

@@ -166,14 +166,9 @@ pub enum ChunkingType {
  /// Referenced asset will not inherit the available modules, but form a
  /// new availability root.
  IsolatedParallel,
- /// Asset is placed in a separate chunk group that is referenced from the
- /// referencing chunk group, but not loaded.
- /// Note: Separate chunks need to be loaded by something external to current
- /// reference.
- Separate,
  /// An async loader is placed into the referencing chunk and loads the
  /// separate chunk group in which the asset is placed.
- SeparateAsync,
+ Async,
 }
 
 #[turbo_tasks::value(transparent)]
@@ -239,7 +234,6 @@ impl ValueToString for ChunkGroupReference {
 pub struct ChunkContentResult<I> {
  pub chunk_items: Vec<I>,
  pub chunks: Vec<ChunkVc>,
- pub async_chunk_group_entries: Vec<ChunkVc>,
  pub external_asset_references: Vec<AssetReferenceVc>,
  pub availability_info: AvailabilityInfo,
 }
@@ -289,9 +283,6 @@ enum ChunkContentGraphNode<I> {
  AvailableAsset(AssetVc),
  // Chunks that are loaded in parallel to the current chunk
  Chunk(ChunkVc),
- // Chunk groups that are referenced from the current chunk, but
- // not loaded in parallel
- AsyncChunkGroup { entry: ChunkVc },
  ExternalAssetReference(AssetReferenceVc),
 }
 
@@ -414,16 +405,7 @@ where
  ChunkContentGraphNode::Chunk(chunk),
  ));
  }
- ChunkingType::Separate => {
- graph_nodes.push((
- Some((asset, chunking_type)),
- ChunkContentGraphNode::AsyncChunkGroup {
- entry: chunkable_asset
- .as_chunk(context.chunking_context, context.availability_info),
- },
- ));
- }
- ChunkingType::SeparateAsync => {
+ ChunkingType::Async => {
  if let Some(manifest_loader_item) = I::from_async_asset(
  context.chunking_context,
  chunkable_asset,
@@ -594,7 +576,6 @@ where
 
  let mut chunk_items = Vec::new();
  let mut chunks = Vec::new();
- let mut async_chunk_group_entries = Vec::new();
  let mut external_asset_references = Vec::new();
 
  for graph_node in graph_nodes {
@@ -606,9 +587,6 @@ where
  ChunkContentGraphNode::Chunk(chunk) => {
  chunks.push(chunk);
  }
- ChunkContentGraphNode::AsyncChunkGroup { entry } => {
- async_chunk_group_entries.push(entry);
- }
  ChunkContentGraphNode::ExternalAssetReference(reference) => {
  external_asset_references.push(reference);
  }
@@ -618,7 +596,6 @@ where
  Ok(Some(ChunkContentResult {
  chunk_items,
  chunks,
- async_chunk_group_entries,
  external_asset_references,
  availability_info: availability_info.into_value(),
  }))

crates/turbopack-core/src/introspect/asset.rs

@@ -54,11 +54,6 @@ fn isolated_parallel_reference_ty() -> StringVc {
  StringVc::cell("isolated parallel reference".to_string())
 }
 
-#[turbo_tasks::function]
-fn separate_reference_ty() -> StringVc {
- StringVc::cell("separate reference".to_string())
-}
-
 #[turbo_tasks::function]
 fn async_reference_ty() -> StringVc {
  StringVc::cell("async reference".to_string())
@@ -121,9 +116,8 @@ pub async fn children_from_asset_references(
  Some(ChunkingType::Placed) => key = placed_reference_ty(),
  Some(ChunkingType::Parallel) => key = parallel_reference_ty(),
  Some(ChunkingType::IsolatedParallel) => key = isolated_parallel_reference_ty(),
- Some(ChunkingType::Separate) => key = separate_reference_ty(),
  Some(ChunkingType::PlacedOrParallel) => key = placed_or_parallel_reference_ty(),
- Some(ChunkingType::SeparateAsync) => key = async_reference_ty(),
+ Some(ChunkingType::Async) => key = async_reference_ty(),
  }
  }
 

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

@@ -12,10 +12,9 @@ use turbopack_core::{
  asset::{Asset, AssetContentVc, AssetVc, AssetsVc},
  chunk::{
  availability_info::AvailabilityInfo, chunk_content, chunk_content_split, Chunk,
- ChunkContentResult, ChunkGroupReferenceVc, ChunkItem, ChunkItemVc, ChunkVc,
- ChunkableAssetVc, ChunkingContext, ChunkingContextVc, ChunksVc, FromChunkableAsset,
- ModuleId, ModuleIdVc, ModuleIdsVc, OutputChunk, OutputChunkRuntimeInfo,
- OutputChunkRuntimeInfoVc, OutputChunkVc,
+ ChunkContentResult, ChunkItem, ChunkItemVc, ChunkVc, ChunkableAssetVc, ChunkingContext,
+ ChunkingContextVc, ChunksVc, FromChunkableAsset, ModuleId, ModuleIdVc, ModuleIdsVc,
+ OutputChunk, OutputChunkRuntimeInfo, OutputChunkRuntimeInfoVc, OutputChunkVc,
  },
  code_builder::{CodeBuilder, CodeVc},
  ident::{AssetIdent, AssetIdentVc},
@@ -202,7 +201,6 @@ impl GenerateSourceMap for CssChunkContent {
 pub struct CssChunkContentResult {
  pub chunk_items: Vec<CssChunkItemVc>,
  pub chunks: Vec<ChunkVc>,
- pub async_chunk_group_entries: Vec<ChunkVc>,
  pub external_asset_references: Vec<AssetReferenceVc>,
 }
 
@@ -211,7 +209,6 @@ impl From<ChunkContentResult<CssChunkItemVc>> for CssChunkContentResult {
  CssChunkContentResult {
  chunk_items: from.chunk_items,
  chunks: from.chunks,
- async_chunk_group_entries: from.async_chunk_group_entries,
  external_asset_references: from.external_asset_references,
  }
  }
@@ -236,26 +233,22 @@ async fn css_chunk_content(
 
  let mut all_chunk_items = IndexSet::<CssChunkItemVc>::new();
  let mut all_chunks = IndexSet::<ChunkVc>::new();
- let mut all_async_chunk_group_entries = IndexSet::<ChunkVc>::new();
  let mut all_external_asset_references = IndexSet::<AssetReferenceVc>::new();
 
  for content in contents {
  let CssChunkContentResult {
  chunk_items,
  chunks,
- async_chunk_group_entries,
  external_asset_references,
  } = &*content.await?;
  all_chunk_items.extend(chunk_items.iter().copied());
  all_chunks.extend(chunks.iter().copied());
- all_async_chunk_group_entries.extend(async_chunk_group_entries.iter().copied());
  all_external_asset_references.extend(external_asset_references.iter().copied());
  }
 
  Ok(CssChunkContentResult {
  chunk_items: all_chunk_items.into_iter().collect(),
  chunks: all_chunks.into_iter().collect(),
- async_chunk_group_entries: all_async_chunk_group_entries.into_iter().collect(),
  external_asset_references: all_external_asset_references.into_iter().collect(),
  }
  .cell())
@@ -417,9 +410,6 @@ impl Asset for CssChunk {
  }
  }
  }
- for entry in content.async_chunk_group_entries.iter() {
- references.push(ChunkGroupReferenceVc::new(this.context, *entry).into());
- }
  for item in content.chunk_items.iter() {
  references.push(SingleItemCssChunkReferenceVc::new(this.context, *item).into());
  }

crates/turbopack-css/src/chunk/single_item_chunk/reference.rs

@@ -1,10 +1,7 @@
 use anyhow::Result;
 use turbo_tasks::{primitives::StringVc, ValueToString, ValueToStringVc};
 use turbopack_core::{
- chunk::{
- ChunkItem, ChunkableAssetReference, ChunkableAssetReferenceVc, ChunkingContextVc,
- ChunkingType, ChunkingTypeOptionVc,
- },
+ chunk::{ChunkItem, ChunkingContextVc},
  reference::{AssetReference, AssetReferenceVc},
  resolve::{ResolveResult, ResolveResultVc},
 };
@@ -47,11 +44,3 @@ impl ValueToString for SingleItemCssChunkReference {
  )))
  }
 }
-
-#[turbo_tasks::value_impl]
-impl ChunkableAssetReference for SingleItemCssChunkReference {
- #[turbo_tasks::function]
- fn chunking_type(&self) -> Result<ChunkingTypeOptionVc> {
- Ok(ChunkingTypeOptionVc::cell(Some(ChunkingType::Separate)))
- }
-}

crates/turbopack-ecmascript/src/chunk/content.rs

@@ -19,7 +19,6 @@ use super::{
 pub struct EcmascriptChunkContent {
  pub chunk_items: Vec<EcmascriptChunkItemVc>,
  pub chunks: Vec<ChunkVc>,
- pub async_chunk_group_entries: Vec<ChunkVc>,
  pub external_asset_references: Vec<AssetReferenceVc>,
  pub availability_info: AvailabilityInfo,
 }
@@ -29,7 +28,6 @@ impl From<ChunkContentResult<EcmascriptChunkItemVc>> for EcmascriptChunkContent
  EcmascriptChunkContent {
  chunk_items: from.chunk_items,
  chunks: from.chunks,
- async_chunk_group_entries: from.async_chunk_group_entries,
  external_asset_references: from.external_asset_references,
  availability_info: from.availability_info,
  }
@@ -80,27 +78,23 @@ async fn ecmascript_chunk_content_internal(
 
  let mut all_chunk_items = IndexSet::<EcmascriptChunkItemVc>::new();
  let mut all_chunks = IndexSet::<ChunkVc>::new();
- let mut all_async_chunk_group_entries = IndexSet::<ChunkVc>::new();
  let mut all_external_asset_references = IndexSet::<AssetReferenceVc>::new();
 
  for content in contents {
  let EcmascriptChunkContent {
  chunk_items,
  chunks,
- async_chunk_group_entries,
  external_asset_references,
  availability_info: _,
  } = &*content.await?;
  all_chunk_items.extend(chunk_items.iter().copied());
  all_chunks.extend(chunks.iter().copied());
- all_async_chunk_group_entries.extend(async_chunk_group_entries.iter().copied());
  all_external_asset_references.extend(external_asset_references.iter().copied());
  }
 
  Ok(EcmascriptChunkContent {
  chunk_items: all_chunk_items.into_iter().collect(),
  chunks: all_chunks.into_iter().collect(),
- async_chunk_group_entries: all_async_chunk_group_entries.into_iter().collect(),
  external_asset_references: all_external_asset_references.into_iter().collect(),
  availability_info: availability_info.into_value(),
  }

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

@@ -16,8 +16,8 @@ use turbo_tasks_fs::FileSystemPathOptionVc;
 use turbopack_core::{
  asset::{Asset, AssetContentVc, AssetVc},
  chunk::{
- availability_info::AvailabilityInfo, Chunk, ChunkGroupReferenceVc, ChunkItem, ChunkVc,
- ChunkingContextVc, ChunksVc, ModuleIdsVc,
+ availability_info::AvailabilityInfo, Chunk, ChunkItem, ChunkVc, ChunkingContextVc,
+ ChunksVc, ModuleIdsVc,
  },
  ident::{AssetIdent, AssetIdentVc},
  introspect::{
@@ -392,9 +392,6 @@ impl Asset for EcmascriptChunk {
  for r in content.external_asset_references.iter() {
  references.push(*r);
  }
- for entry in content.async_chunk_group_entries.iter() {
- references.push(ChunkGroupReferenceVc::new(this.context.into(), *entry).into());
- }
 
  Ok(AssetReferencesVc::cell(references))
  }

crates/turbopack-ecmascript/src/references/esm/base.rs

@@ -180,7 +180,6 @@ impl ChunkableAssetReference for EsmAssetReference {
  Ok(ChunkingTypeOptionVc::cell(
  if let Some(chunking_type) = self.annotations.chunking_type() {
  match chunking_type {
- "separate" => Some(ChunkingType::Separate),
  "parallel" => Some(ChunkingType::Parallel),
  "isolatedParallel" => Some(ChunkingType::IsolatedParallel),
  "none" => None,
@@ -222,8 +221,8 @@ impl CodeGenerateable for EsmAssetReference {
  return Ok(CodeGeneration { visitors }.into());
  }
 
- // separate chunks can't be imported as the modules are not available
- if !matches!(*chunking_type, None | Some(ChunkingType::Separate)) {
+ // only chunked references can be imported
+ if chunking_type.is_some() {
  let referenced_asset = self_vc.get_referenced_asset().await?;
  if let Some(ident) = referenced_asset.get_ident().await? {
  match &*referenced_asset {

crates/turbopack-ecmascript/src/references/esm/dynamic.rs

@@ -86,7 +86,7 @@ impl ValueToString for EsmAsyncAssetReference {
 impl ChunkableAssetReference for EsmAsyncAssetReference {
  #[turbo_tasks::function]
  fn chunking_type(&self) -> ChunkingTypeOptionVc {
- ChunkingTypeOptionVc::cell(Some(ChunkingType::SeparateAsync))
+ ChunkingTypeOptionVc::cell(Some(ChunkingType::Async))
  }
 }