Module Trait (#5477)

### Description

First step in having separate traits for Source, Module and Outputs.

next.js PR: vercel/next.js#52401

crates/node-file-trace/src/lib.rs

@@ -214,10 +214,14 @@ async fn add_glob_results(
     for entry in result.results.values() {
         if let DirectoryEntry::File(path) = entry {
             let source = SourceAssetVc::new(*path).into();
-            list.push(context.process(
-                source,
-                Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
-            ));
+            list.push(
+                context
+                    .process(
+                        source,
+                        Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
+                    )
+                    .into(),
+            );
         }
     }
     for result in result.inner.values() {
@@ -256,10 +260,14 @@ async fn input_to_modules<'a>(
     for input in input.iter() {
         if exact {
             let source = SourceAssetVc::new(root.join(input)).into();
-            list.push(context.process(
-                source,
-                Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
-            ));
+            list.push(
+                context
+                    .process(
+                        source,
+                        Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
+                    )
+                    .into(),
+            );
         } else {
             let glob = GlobVc::new(input);
             add_glob_results(context, root.read_glob(glob, false), &mut list).await?;

crates/turbopack-build/src/chunking_context.rs

@@ -9,7 +9,7 @@ use turbo_tasks_fs::FileSystemPathVc;
 use turbopack_core::{
     asset::{Asset, AssetVc, AssetsVc},
     chunk::{
-        Chunk, ChunkVc, ChunkableAsset, ChunkingContext, ChunkingContextVc, ChunksVc,
+        Chunk, ChunkVc, ChunkableModule, ChunkingContext, ChunkingContextVc, ChunksVc,
         EvaluatableAssetsVc,
     },
     environment::EnvironmentVc,

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

@@ -17,7 +17,7 @@ use turbopack::{
 };
 use turbopack_cli_utils::runtime_entry::{RuntimeEntriesVc, RuntimeEntry};
 use turbopack_core::{
-    chunk::{ChunkableAssetVc, ChunkingContextVc},
+    chunk::{ChunkableModuleVc, ChunkingContextVc},
     compile_time_defines,
     compile_time_info::{CompileTimeDefinesVc, CompileTimeInfo, CompileTimeInfoVc},
     context::AssetContextVc,
@@ -289,7 +289,7 @@ pub async fn create_web_entry_source(
                     chunking_context,
                     Some(runtime_entries.with_entry(ecmascript.into())),
                 ))
-            } else if let Some(chunkable) = ChunkableAssetVc::resolve_from(module).await? {
+            } else if let Some(chunkable) = ChunkableModuleVc::resolve_from(module).await? {
                 // TODO this is missing runtime code, so it's probably broken and we should also
                 // add an ecmascript chunk with the runtime code
                 Ok((chunkable, chunking_context, None))

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

@@ -9,7 +9,7 @@ use turbo_tasks::{
 };
 use turbo_tasks_hash::Xxh3Hash64Hasher;
 
-use super::{ChunkableAssetReference, ChunkableAssetReferenceVc, ChunkingType};
+use super::{ChunkableModuleReference, ChunkableModuleReferenceVc, ChunkingType};
 use crate::{
     asset::{Asset, AssetVc, AssetsSetVc},
     reference::AssetReference,
@@ -93,7 +93,7 @@ async fn chunkable_assets_set(root: AssetVc) -> Result<AssetsSetVc> {
                 .copied()
                 .map(|reference| async move {
                     if let Some(chunkable) =
-                        ChunkableAssetReferenceVc::resolve_from(reference).await?
+                        ChunkableModuleReferenceVc::resolve_from(reference).await?
                     {
                         if matches!(
                             &*chunkable.chunking_type().await?,

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

@@ -1,10 +1,11 @@
 use anyhow::{bail, Result};
 use turbo_tasks::{Value, ValueToString};
 
-use super::{ChunkableAsset, ChunkableAssetVc};
+use super::{ChunkableModule, ChunkableModuleVc};
 use crate::{
     asset::{Asset, AssetVc},
     context::{AssetContext, AssetContextVc},
+    module::{Module, ModuleVc},
     reference_type::{EntryReferenceSubType, ReferenceType},
 };
 
@@ -13,7 +14,7 @@ use crate::{
 /// The chunking context implementation will resolve the dynamic entry to a
 /// well-known value or trait object.
 #[turbo_tasks::value_trait]
-pub trait EvaluatableAsset: Asset + ChunkableAsset {}
+pub trait EvaluatableAsset: Asset + Module + ChunkableModule {}
 
 #[turbo_tasks::value_impl]
 impl EvaluatableAssetVc {

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

@@ -38,6 +38,7 @@ pub use self::{
 use crate::{
     asset::{Asset, AssetVc, AssetsVc},
     ident::AssetIdentVc,
+    module::{Module, ModuleVc},
     reference::{AssetReference, AssetReferenceVc, AssetReferencesVc},
     resolve::{PrimaryResolveResult, ResolveResult, ResolveResultVc},
 };
@@ -83,14 +84,14 @@ pub struct ModuleIds(Vec<ModuleIdVc>);
 
 /// An [Asset] that can be converted into a [Chunk].
 #[turbo_tasks::value_trait]
-pub trait ChunkableAsset: Asset {
+pub trait ChunkableModule: Module + Asset {
     fn as_chunk(
         &self,
         context: ChunkingContextVc,
         availability_info: Value<AvailabilityInfo>,
     ) -> ChunkVc;
 
-    fn as_root_chunk(self_vc: ChunkableAssetVc, context: ChunkingContextVc) -> ChunkVc {
+    fn as_root_chunk(self_vc: ChunkableModuleVc, context: ChunkingContextVc) -> ChunkVc {
         self_vc.as_chunk(
             context,
             Value::new(AvailabilityInfo::Root {
@@ -177,13 +178,13 @@ pub enum ChunkingType {
 pub struct ChunkingTypeOption(Option<ChunkingType>);
 
 /// An [AssetReference] implementing this trait and returning true for
-/// [ChunkableAssetReference::is_chunkable] are considered as potentially
+/// [ChunkableModuleReference::is_chunkable] are considered as potentially
 /// chunkable references. When all [Asset]s of such a reference implement
-/// [ChunkableAsset] they are placed in [Chunk]s during chunking.
+/// [ChunkableModule] they are placed in [Chunk]s during chunking.
 /// They are even potentially placed in the same [Chunk] when a chunk type
 /// specific interface is implemented.
 #[turbo_tasks::value_trait]
-pub trait ChunkableAssetReference: AssetReference + ValueToString {
+pub trait ChunkableModuleReference: AssetReference + ValueToString {
     fn chunking_type(&self) -> ChunkingTypeOptionVc {
         ChunkingTypeOptionVc::cell(Some(ChunkingType::default()))
     }
@@ -241,11 +242,11 @@ pub struct ChunkContentResult<I> {
 }
 
 #[async_trait::async_trait]
-pub trait FromChunkableAsset: ChunkItem + Sized + Debug {
+pub trait FromChunkableModule: ChunkItem + Sized + Debug {
     async fn from_asset(context: ChunkingContextVc, asset: AssetVc) -> Result<Option<Self>>;
     async fn from_async_asset(
         context: ChunkingContextVc,
-        asset: ChunkableAssetVc,
+        asset: ChunkableModuleVc,
         availability_info: Value<AvailabilityInfo>,
     ) -> Result<Option<Self>>;
 }
@@ -257,7 +258,7 @@ pub async fn chunk_content_split<I>(
     availability_info: Value<AvailabilityInfo>,
 ) -> Result<ChunkContentResult<I>>
 where
-    I: FromChunkableAsset + Eq + std::hash::Hash + Clone,
+    I: FromChunkableModule + Eq + std::hash::Hash + Clone,
 {
     chunk_content_internal_parallel(context, entry, additional_entries, availability_info, true)
         .await
@@ -271,7 +272,7 @@ pub async fn chunk_content<I>(
     availability_info: Value<AvailabilityInfo>,
 ) -> Result<Option<ChunkContentResult<I>>>
 where
-    I: FromChunkableAsset + Eq + std::hash::Hash + Clone,
+    I: FromChunkableModule + Eq + std::hash::Hash + Clone,
 {
     chunk_content_internal_parallel(context, entry, additional_entries, availability_info, false)
         .await
@@ -304,10 +305,10 @@ async fn reference_to_graph_nodes<I>(
     reference: AssetReferenceVc,
 ) -> Result<Vec<(Option<(AssetVc, ChunkingType)>, ChunkContentGraphNode<I>)>>
 where
-    I: FromChunkableAsset + Eq + std::hash::Hash + Clone,
+    I: FromChunkableModule + Eq + std::hash::Hash + Clone,
 {
     let Some(chunkable_asset_reference) =
-        ChunkableAssetReferenceVc::resolve_from(reference).await?
+        ChunkableModuleReferenceVc::resolve_from(reference).await?
     else {
         return Ok(vec![(
             None,
@@ -351,7 +352,7 @@ where
             continue;
         }
 
-        let chunkable_asset = match ChunkableAssetVc::resolve_from(asset).await? {
+        let chunkable_asset = match ChunkableModuleVc::resolve_from(asset).await? {
             Some(chunkable_asset) => chunkable_asset,
             _ => {
                 return Ok(vec![(
@@ -465,12 +466,12 @@ struct ChunkContentVisit<I> {
 type ChunkItemToGraphNodesEdges<I> =
     impl Iterator<Item = (Option<(AssetVc, ChunkingType)>, ChunkContentGraphNode<I>)>;
 
-type ChunkItemToGraphNodesFuture<I: FromChunkableAsset + Eq + std::hash::Hash + Clone> =
+type ChunkItemToGraphNodesFuture<I: FromChunkableModule + Eq + std::hash::Hash + Clone> =
     impl Future<Output = Result<ChunkItemToGraphNodesEdges<I>>>;
 
 impl<I> Visit<ChunkContentGraphNode<I>, ()> for ChunkContentVisit<I>
 where
-    I: FromChunkableAsset + Eq + std::hash::Hash + Clone,
+    I: FromChunkableModule + Eq + std::hash::Hash + Clone,
 {
     type Edge = (Option<(AssetVc, ChunkingType)>, ChunkContentGraphNode<I>);
     type EdgesIntoIter = ChunkItemToGraphNodesEdges<I>;
@@ -545,7 +546,7 @@ async fn chunk_content_internal_parallel<I>(
     split: bool,
 ) -> Result<Option<ChunkContentResult<I>>>
 where
-    I: FromChunkableAsset + Eq + std::hash::Hash + Clone,
+    I: FromChunkableModule + Eq + std::hash::Hash + Clone,
 {
     let additional_entries = if let Some(additional_entries) = additional_entries {
         additional_entries.await?.clone_value().into_iter()

crates/turbopack-core/src/context.rs

@@ -5,6 +5,7 @@ use turbo_tasks_fs::FileSystemPathVc;
 use crate::{
     asset::AssetVc,
     compile_time_info::CompileTimeInfoVc,
+    module::ModuleVc,
     reference_type::ReferenceType,
     resolve::{options::ResolveOptionsVc, parse::RequestVc, ResolveResultVc},
 };
@@ -27,7 +28,7 @@ pub trait AssetContext {
         resolve_options: ResolveOptionsVc,
         reference_type: Value<ReferenceType>,
     ) -> ResolveResultVc;
-    fn process(&self, asset: AssetVc, reference_type: Value<ReferenceType>) -> AssetVc;
+    fn process(&self, asset: AssetVc, reference_type: Value<ReferenceType>) -> ModuleVc;
     fn process_resolve_result(
         &self,
         result: ResolveResultVc,

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

@@ -6,7 +6,7 @@ use turbo_tasks_fs::FileContent;
 use super::{Introspectable, IntrospectableChildrenVc, IntrospectableVc};
 use crate::{
     asset::{Asset, AssetContent, AssetContentVc, AssetVc},
-    chunk::{ChunkableAssetReference, ChunkableAssetReferenceVc, ChunkingType},
+    chunk::{ChunkableModuleReference, ChunkableModuleReferenceVc, ChunkingType},
     reference::{AssetReference, AssetReferencesVc},
     resolve::PrimaryResolveResult,
 };
@@ -110,7 +110,7 @@ pub async fn children_from_asset_references(
     let references = references.await?;
     for reference in &*references {
         let mut key = key;
-        if let Some(chunkable) = ChunkableAssetReferenceVc::resolve_from(reference).await? {
+        if let Some(chunkable) = ChunkableModuleReferenceVc::resolve_from(reference).await? {
             match &*chunkable.chunking_type().await? {
                 None => {}
                 Some(ChunkingType::Placed) => key = placed_reference_ty(),

crates/turbopack-core/src/lib.rs

@@ -16,8 +16,10 @@ pub mod error;
 pub mod ident;
 pub mod introspect;
 pub mod issue;
+pub mod module;
 pub mod package_json;
 pub mod proxied_asset;
+pub mod raw_module;
 pub mod reference;
 pub mod reference_type;
 pub mod resolve;

crates/turbopack-core/src/module.rs

@@ -0,0 +1,9 @@
+use crate::asset::{Asset, AssetVc};
+
+/// A module. This usually represents parsed source code, which has references
+/// to other modules.
+#[turbo_tasks::value_trait]
+pub trait Module: Asset {}
+
+#[turbo_tasks::value(transparent)]
+pub struct OptionModule(Option<ModuleVc>);

crates/turbopack-core/src/raw_module.rs

@@ -0,0 +1,36 @@
+use crate::{
+    asset::{Asset, AssetContentVc, AssetVc},
+    ident::AssetIdentVc,
+    module::{Module, ModuleVc},
+};
+
+/// A module where source code doesn't need to be parsed but can be usd as is.
+/// This module has no references to other modules.
+#[turbo_tasks::value]
+pub struct RawModule {
+    source: AssetVc,
+}
+
+#[turbo_tasks::value_impl]
+impl Module for RawModule {}
+
+#[turbo_tasks::value_impl]
+impl Asset for RawModule {
+    #[turbo_tasks::function]
+    fn ident(&self) -> AssetIdentVc {
+        self.source.ident()
+    }
+
+    #[turbo_tasks::function]
+    fn content(&self) -> AssetContentVc {
+        self.source.content()
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl RawModuleVc {
+    #[turbo_tasks::function]
+    pub fn new(source: AssetVc) -> RawModuleVc {
+        RawModule { source }.cell()
+    }
+}

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

@@ -14,10 +14,10 @@ pub use source_map::SourceMapReferenceVc;
 
 /// A reference to one or multiple [Asset]s or other special things.
 /// There are a bunch of optional traits that can influence how these references
-/// are handled. e. g. [ChunkableAssetReference]
+/// are handled. e. g. [ChunkableModuleReference]
 ///
 /// [Asset]: crate::asset::Asset
-/// [ChunkableAssetReference]: crate::chunk::ChunkableAssetReference
+/// [ChunkableModuleReference]: crate::chunk::ChunkableModuleReference
 #[turbo_tasks::value_trait]
 pub trait AssetReference: ValueToString {
     fn resolve_reference(&self) -> ResolveResultVc;

crates/turbopack-css/src/asset.rs

@@ -12,11 +12,12 @@ use turbo_tasks_fs::FileSystemPathVc;
 use turbopack_core::{
     asset::{Asset, AssetContentVc, AssetVc},
     chunk::{
-        availability_info::AvailabilityInfo, ChunkItem, ChunkItemVc, ChunkVc, ChunkableAsset,
-        ChunkableAssetVc, ChunkingContextVc,
+        availability_info::AvailabilityInfo, ChunkItem, ChunkItemVc, ChunkVc, ChunkableModule,
+        ChunkableModuleVc, ChunkingContextVc,
     },
     context::AssetContextVc,
     ident::AssetIdentVc,
+    module::{Module, ModuleVc},
     reference::{AssetReference, AssetReferencesVc},
     resolve::{
         origin::{ResolveOrigin, ResolveOriginVc},
@@ -115,7 +116,10 @@ impl Asset for CssModuleAsset {
 }
 
 #[turbo_tasks::value_impl]
-impl ChunkableAsset for CssModuleAsset {
+impl Module for CssModuleAsset {}
+
+#[turbo_tasks::value_impl]
+impl ChunkableModule for CssModuleAsset {
     #[turbo_tasks::function]
     fn as_chunk(
         self_vc: CssModuleAssetVc,

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

@@ -12,8 +12,8 @@ use turbopack_core::{
     asset::{Asset, AssetContentVc, AssetVc, AssetsVc},
     chunk::{
         availability_info::AvailabilityInfo, chunk_content, chunk_content_split, Chunk,
-        ChunkContentResult, ChunkItem, ChunkItemVc, ChunkVc, ChunkableAssetVc, ChunkingContext,
-        ChunkingContextVc, ChunksVc, FromChunkableAsset, ModuleId, ModuleIdVc, ModuleIdsVc,
+        ChunkContentResult, ChunkItem, ChunkItemVc, ChunkVc, ChunkableModuleVc, ChunkingContext,
+        ChunkingContextVc, ChunksVc, FromChunkableModule, ModuleId, ModuleIdVc, ModuleIdsVc,
         OutputChunk, OutputChunkRuntimeInfo, OutputChunkRuntimeInfoVc, OutputChunkVc,
     },
     code_builder::{CodeBuilder, CodeVc},
@@ -489,7 +489,7 @@ pub trait CssChunkItem: ChunkItem {
 }
 
 #[async_trait::async_trait]
-impl FromChunkableAsset for CssChunkItemVc {
+impl FromChunkableModule for CssChunkItemVc {
     async fn from_asset(context: ChunkingContextVc, asset: AssetVc) -> Result<Option<Self>> {
         if let Some(placeable) = CssChunkPlaceableVc::resolve_from(asset).await? {
             return Ok(Some(placeable.as_chunk_item(context)));
@@ -499,7 +499,7 @@ impl FromChunkableAsset for CssChunkItemVc {
 
     async fn from_async_asset(
         _context: ChunkingContextVc,
-        _asset: ChunkableAssetVc,
+        _asset: ChunkableModuleVc,
         _availability_info: Value<AvailabilityInfo>,
     ) -> Result<Option<Self>> {
         Ok(None)