Cleanup pass

Author: mmastrac

crates/next-api/src/pages.rs

@@ -44,8 +44,8 @@ use turbopack::{
 use turbopack_core::{
     asset::AssetContent,
     chunk::{
-        ChunkGroupResult, ChunkType, ChunkingContext, ChunkingContextExt, EvaluatableAsset,
-        EvaluatableAssets, availability_info::AvailabilityInfo,
+        ChunkGroupResult, ChunkingContext, ChunkingContextExt,
+        EvaluatableAsset, EvaluatableAssets, availability_info::AvailabilityInfo,
     },
     context::AssetContext,
     file_source::FileSource,
@@ -657,36 +657,28 @@ impl PageEndpoint {
             Vc::upcast(this.pages_project.client_module_context()),
             self.source(),
             this.pathname.clone(),
-        );
-        let is_chunkable = {
-            let page_loader_resolved = page_loader.to_resolved().await?;
-            let configs = this
-                .pages_project
-                .project()
-                .client_chunking_context()
-                .chunking_configs()
-                .await?;
-            let mut chunkable = false;
-            for (chunk_type, _) in configs.iter() {
-                if *chunk_type.accepts_module(*page_loader_resolved).await? {
-                    chunkable = true;
-                    break;
-                }
-            }
-            chunkable
-        };
+        )
+        .to_resolved()
+        .await?;
+        let is_chunkable = this
+            .pages_project
+            .project()
+            .client_chunking_context()
+            .chunking_configs()
+            .await?
+            .is_chunkable(page_loader)
+            .await;
         if matches!(
             *this.pages_project.project().next_mode().await?,
             NextMode::Development
         ) && is_chunkable
         {
-            let module = page_loader.to_resolved().await?;
             return Ok(Vc::upcast(HmrEntryModule::new(
                 AssetIdent::from_path(this.page.await?.base_path.clone()),
-                *module,
+                *page_loader,
             )));
         }
-        Ok(page_loader)
+        Ok(*page_loader)
     }
 
     #[turbo_tasks::function]

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -688,7 +688,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
     #[turbo_tasks::function]
     fn chunking_configs(&self) -> Result<Vc<ChunkingConfigs>> {
-        Ok(Vc::cell(self.chunking_configs.iter().cloned().collect()))
+        Ok(ChunkingConfigs(self.chunking_configs.iter().cloned().collect()).cell())
     }
 
     #[turbo_tasks::function]

turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs

@@ -1,12 +1,12 @@
-use anyhow::{Result, anyhow};
+use anyhow::Result;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, Vc};
 use turbo_tasks_env::ProcessEnv;
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_browser::{BrowserChunkingContext, react_refresh::assert_can_resolve_react_refresh};
 use turbopack_cli_utils::runtime_entry::{RuntimeEntries, RuntimeEntry};
 use turbopack_core::{
-    chunk::{ChunkType, ChunkingContext, EvaluatableAsset, SourceMapSourceType, SourceMapsType},
+    chunk::{ChunkItem, ChunkingContext, EvaluatableAsset, SourceMapSourceType, SourceMapsType},
     environment::Environment,
     file_source::FileSource,
     module::Module,
@@ -169,37 +169,19 @@ pub async fn create_web_entry_source(
     let entries: Vec<_> = entries
         .into_iter()
         .map(|module| async move {
-            let mut is_chunkable = false;
-            {
-                let configs = chunking_context.chunking_configs().await?;
-                for (chunk_type, _) in configs.iter() {
-                    if *chunk_type.accepts_module(*module).await? {
-                        is_chunkable = true;
-                        break;
-                    }
-                }
-            }
-            if !is_chunkable {
-                // TODO convert into a serve-able asset
-                return Err(anyhow!(
-                    "Entry module is not chunkable, so it can't be used to bootstrap the \
-                     application"
-                ));
-            }
+            let chunk_item = ChunkItem::new(*module, *module_graph, *chunking_context)
+                .to_resolved()
+                .await?;
             if let Some(entry) = ResolvedVc::try_sidecast::<Box<dyn EvaluatableAsset>>(module) {
                 Ok(DevHtmlEntry {
-                    chunkable_module: module,
-                    module_graph,
-                    chunking_context,
+                    chunk_item,
                     runtime_entries: Some(runtime_entries.with_entry(*entry).to_resolved().await?),
                 })
             } else {
                 // TODO this is missing runtime code, so it's probably broken and we should also
                 // add an ecmascript chunk with the runtime code
                 Ok(DevHtmlEntry {
-                    chunkable_module: module,
-                    module_graph,
-                    chunking_context,
+                    chunk_item,
                     runtime_entries: None,
                 })
             }

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

@@ -1,9 +1,13 @@
+use std::ops::Deref;
+
 use anyhow::{Result, bail};
 use bincode::{Decode, Encode};
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
-use turbo_tasks::{NonLocalValue, ResolvedVc, TaskInput, Upcast, Vc, trace::TraceRawVcs};
+use turbo_tasks::{
+    IntoTraitRef, NonLocalValue, ResolvedVc, TaskInput, Upcast, Vc, trace::TraceRawVcs,
+};
 use turbo_tasks_fs::FileSystemPath;
 use turbo_tasks_hash::DeterministicHash;
 
@@ -276,8 +280,40 @@ pub struct ChunkingConfig {
     pub placeholder_for_future_extensions: (),
 }
 
-#[turbo_tasks::value(transparent)]
-pub struct ChunkingConfigs(FxHashMap<ResolvedVc<Box<dyn ChunkType>>, ChunkingConfig>);
+#[derive(Default)]
+#[turbo_tasks::value(shared)]
+pub struct ChunkingConfigs(pub FxHashMap<ResolvedVc<Box<dyn ChunkType>>, ChunkingConfig>);
+
+impl Deref for ChunkingConfigs {
+    type Target = FxHashMap<ResolvedVc<Box<dyn ChunkType>>, ChunkingConfig>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl ChunkingConfigs {
+    pub async fn is_chunkable(&self, module: ResolvedVc<Box<dyn Module>>) -> bool {
+        self.chunk_type(module).await.is_some()
+    }
+
+    /// Returns a [`ChunkType`], if one is supported by this module.
+    pub async fn chunk_type(
+        &self,
+        module: ResolvedVc<Box<dyn Module>>,
+    ) -> Option<ResolvedVc<Box<dyn ChunkType>>> {
+        for (chunk_type, _) in &self.0 {
+            if chunk_type
+                .into_trait_ref()
+                .await
+                .expect("Unexpectedly failed to cast trait")
+                .accepts_module(module)
+            {
+                return Some(*chunk_type);
+            }
+        }
+        None
+    }
+}
 
 #[turbo_tasks::value(shared)]
 #[derive(Debug, Clone, Copy, Hash, TaskInput, Default, Deserialize)]
@@ -373,7 +409,7 @@ pub trait ChunkingContext {
 
     #[turbo_tasks::function]
     fn chunking_configs(self: Vc<Self>) -> Vc<ChunkingConfigs> {
-        Vc::cell(Default::default())
+        ChunkingConfigs::default().cell()
     }
 
     #[turbo_tasks::function]

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

@@ -384,23 +384,37 @@ pub struct ChunkItem {
     pub module: ResolvedVc<Box<dyn Module>>,
     pub chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
     pub module_graph: ResolvedVc<ModuleGraph>,
+    pub ty: ResolvedVc<Box<dyn ChunkType>>,
 }
 
 #[turbo_tasks::value_impl]
 impl ChunkItem {
     /// Create a new [ChunkItem] from a [Module].
     #[turbo_tasks::function]
-    pub fn new(
+    pub async fn new(
         module: ResolvedVc<Box<dyn Module>>,
         module_graph: ResolvedVc<ModuleGraph>,
         chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Self> {
-        Self {
+    ) -> Result<Vc<Self>> {
+        let Some(ty) = chunking_context
+            .chunking_configs()
+            .await?
+            .chunk_type(module)
+            .await
+        else {
+            bail!(
+                "Module {} is not chunkable (at least given the current config)",
+                module.ident_string().await?.to_string()
+            );
+        };
+
+        Ok(Self {
             module,
             chunking_context,
             module_graph,
+            ty,
         }
-        .cell()
+        .cell())
     }
 
     /// The [AssetIdent] of the [Module] that this [ChunkItem] was created from.
@@ -416,33 +430,15 @@ impl ChunkItem {
     /// different when the chunk item content depends on available modules e. g.
     /// for chunk loaders.
     #[turbo_tasks::function]
-    pub async fn content_ident(&self) -> Result<Vc<AssetIdent>> {
-        let configs = self.chunking_context.chunking_configs().await?;
-        for (chunk_type, _) in configs.iter() {
-            if *chunk_type.accepts_module(*self.module).await? {
-                return Ok(chunk_type.chunk_item_content_ident(
-                    *self.module,
-                    *self.chunking_context,
-                    *self.module_graph,
-                ));
-            }
-        }
-        Ok(self.module.ident())
+    pub async fn content_ident(&self) -> Vc<AssetIdent> {
+        self.ty
+            .chunk_item_content_ident(*self.module, *self.chunking_context, *self.module_graph)
     }
 
     /// The type of chunk this item should be assembled into.
     #[turbo_tasks::function]
-    pub async fn ty(&self) -> Result<Vc<Box<dyn ChunkType>>> {
-        let configs = self.chunking_context.chunking_configs().await?;
-        for (chunk_type, _) in configs.iter() {
-            if *chunk_type.accepts_module(*self.module).await? {
-                return Ok(**chunk_type);
-            }
-        }
-        bail!(
-            "No chunk type accepts module {}",
-            self.module.ident().to_string().await?
-        )
+    pub async fn ty(&self) -> Vc<Box<dyn ChunkType>> {
+        *self.ty
     }
 
     /// Retrieve the module associated with this ChunkItem.
@@ -461,18 +457,10 @@ impl ChunkItem {
 impl OutputAssetsReference for ChunkItem {
     #[turbo_tasks::function]
     async fn references(&self) -> Result<Vc<OutputAssetsWithReferenced>> {
-        let configs = self.chunking_context.chunking_configs().await?;
-        for (chunk_type, _) in configs.iter() {
-            if *chunk_type.accepts_module(*self.module).await? {
-                return Ok(chunk_type.chunk_item_output_assets(
-                    *self.module,
-                    *self.chunking_context,
-                    *self.module_graph,
-                ));
-            }
-        }
-        Ok(OutputAssetsWithReferenced::from_assets(
-            *OutputAssets::empty_resolved(),
+        Ok(self.ty.chunk_item_output_assets(
+            *self.module,
+            *self.chunking_context,
+            *self.module_graph,
         ))
     }
 }
@@ -484,11 +472,7 @@ pub trait ChunkType: ValueToString {
     fn is_style(self: Vc<Self>) -> Vc<bool>;
 
     /// Returns true if this chunk type can handle the given module.
-    #[turbo_tasks::function]
-    fn accepts_module(&self, module: ResolvedVc<Box<dyn Module>>) -> Vc<bool> {
-        let _ = module;
-        Vc::cell(false)
-    }
+    fn accepts_module(&self, module: ResolvedVc<Box<dyn Module>>) -> bool;
 
     /// Create a new chunk for the given chunk items
     #[turbo_tasks::function]