Revert "Turbopack: remove Asset supertrait from Module trait. Modules don't have content" (#86415)

Reverts #86339

Author: sokra

crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_module.rs

@@ -4,9 +4,9 @@ use anyhow::{Context, Result, bail};
 use indoc::writedoc;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{IntoTraitRef, ResolvedVc, ValueToString, Vc};
-use turbo_tasks_fs::File;
+use turbo_tasks_fs::{File, FileContent};
 use turbopack_core::{
-    asset::AssetContent,
+    asset::{Asset, AssetContent},
     chunk::{
         AsyncModuleInfo, ChunkGroupType, ChunkItem, ChunkType, ChunkableModule,
         ChunkableModuleReference, ChunkingContext, ChunkingType, ChunkingTypeOption,
@@ -243,6 +243,18 @@ impl Module for EcmascriptClientReferenceModule {
     }
 }
 
+#[turbo_tasks::value_impl]
+impl Asset for EcmascriptClientReferenceModule {
+    #[turbo_tasks::function]
+    fn content(&self) -> Vc<AssetContent> {
+        AssetContent::File(
+            FileContent::Content("// This is a proxy module for Next.js client references.".into())
+                .resolved_cell(),
+        )
+        .cell()
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl ChunkableModule for EcmascriptClientReferenceModule {
     #[turbo_tasks::function]

crates/next-core/src/next_dynamic/dynamic_module.rs

@@ -4,7 +4,9 @@ use anyhow::Result;
 use indoc::formatdoc;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, Vc};
+use turbo_tasks_fs::FileContent;
 use turbopack_core::{
+    asset::{Asset, AssetContent},
     chunk::{ChunkItem, ChunkType, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::Module,
@@ -71,6 +73,18 @@ impl Module for NextDynamicEntryModule {
     }
 }
 
+#[turbo_tasks::value_impl]
+impl Asset for NextDynamicEntryModule {
+    #[turbo_tasks::function]
+    fn content(&self) -> Vc<AssetContent> {
+        AssetContent::File(
+            FileContent::Content("// This is a marker module for Next.js dynamic.".into())
+                .resolved_cell(),
+        )
+        .cell()
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl ChunkableModule for NextDynamicEntryModule {
     #[turbo_tasks::function]

crates/next-core/src/next_server_component/server_component_module.rs

@@ -4,8 +4,9 @@ use anyhow::Result;
 use indoc::formatdoc;
 use turbo_rcstr::rcstr;
 use turbo_tasks::{ResolvedVc, Vc};
-use turbo_tasks_fs::FileSystemPath;
+use turbo_tasks_fs::{FileContent, FileSystemPath};
 use turbopack_core::{
+    asset::{Asset, AssetContent},
     chunk::{ChunkItem, ChunkType, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::Module,
@@ -68,6 +69,20 @@ impl Module for NextServerComponentModule {
     }
 }
 
+#[turbo_tasks::value_impl]
+impl Asset for NextServerComponentModule {
+    #[turbo_tasks::function]
+    fn content(&self) -> Vc<AssetContent> {
+        AssetContent::File(
+            FileContent::Content(
+                "// This is a marker module for Next.js server components.".into(),
+            )
+            .resolved_cell(),
+        )
+        .cell()
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl ChunkableModule for NextServerComponentModule {
     #[turbo_tasks::function]

crates/next-core/src/next_server_utility/server_utility_module.rs

@@ -4,8 +4,9 @@ use anyhow::Result;
 use indoc::formatdoc;
 use turbo_rcstr::rcstr;
 use turbo_tasks::{ResolvedVc, Vc};
-use turbo_tasks_fs::FileSystemPath;
+use turbo_tasks_fs::{FileContent, FileSystemPath};
 use turbopack_core::{
+    asset::{Asset, AssetContent},
     chunk::{ChunkItem, ChunkType, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::Module,
@@ -68,6 +69,18 @@ impl Module for NextServerUtilityModule {
     }
 }
 
+#[turbo_tasks::value_impl]
+impl Asset for NextServerUtilityModule {
+    #[turbo_tasks::function]
+    fn content(&self) -> Vc<AssetContent> {
+        AssetContent::File(
+            FileContent::Content("// This is a marker module for Next.js server utilities.".into())
+                .resolved_cell(),
+        )
+        .cell()
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl ChunkableModule for NextServerUtilityModule {
     #[turbo_tasks::function]

crates/next-core/src/next_shared/transforms/swc_ecma_transform_plugins.rs

@@ -36,12 +36,11 @@ pub async fn get_swc_ecma_transform_rule_impl(
     enable_mdx_rs: bool,
 ) -> Result<Option<ModuleRule>> {
     use anyhow::bail;
-    use turbo_tasks::{TryFlatJoinIterExt, ValueToString};
+    use turbo_tasks::TryFlatJoinIterExt;
     use turbo_tasks_fs::FileContent;
     use turbopack::{resolve_options, resolve_options_context::ResolveOptionsContext};
     use turbopack_core::{
         asset::Asset,
-        module::Module,
         reference_type::{CommonJsReferenceSubType, ReferenceType},
         resolve::{handle_resolve_error, parse::Request, resolve},
     };
@@ -100,16 +99,7 @@ pub async fn get_swc_ecma_transform_rule_impl(
                     return Ok(None);
                 };
 
-                let Some(plugin_source) = &*plugin_module.source().await? else {
-                    use anyhow::bail;
-
-                    bail!(
-                        "Expected source for plugin module: {}",
-                        plugin_module.ident().to_string().await?
-                    );
-                };
-
-                let content = &*plugin_source.content().file_content().await?;
+                let content = &*plugin_module.content().file_content().await?;
                 let FileContent::Content(file) = content else {
                     bail!("Expected file content for plugin module");
                 };

crates/next-core/src/raw_ecmascript_module.rs

@@ -10,7 +10,7 @@ use turbo_tasks::{FxIndexMap, FxIndexSet, ResolvedVc, TryJoinIterExt, ValueToStr
 use turbo_tasks_fs::{FileContent, glob::Glob, rope::Rope};
 use turbopack::{ModuleAssetContext, module_options::CustomModuleType};
 use turbopack_core::{
-    asset::Asset,
+    asset::{Asset, AssetContent},
     chunk::{ChunkItem, ChunkType, ChunkableModule, ChunkingContext},
     code_builder::CodeBuilder,
     compile_time_info::{
@@ -107,6 +107,14 @@ impl Module for RawEcmascriptModule {
     }
 }
 
+#[turbo_tasks::value_impl]
+impl Asset for RawEcmascriptModule {
+    #[turbo_tasks::function]
+    fn content(&self) -> Vc<AssetContent> {
+        self.source.content()
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl ChunkableModule for RawEcmascriptModule {
     #[turbo_tasks::function]

turbopack/crates/turbopack-core/src/changed.rs

@@ -1,6 +1,6 @@
-use anyhow::{Result, bail};
+use anyhow::Result;
 use turbo_tasks::{
-    Completion, Completions, ResolvedVc, TryJoinIterExt, ValueToString, Vc,
+    Completion, Completions, ResolvedVc, TryJoinIterExt, Vc,
     graph::{AdjacencyMap, GraphTraversal},
 };
 
@@ -33,7 +33,7 @@ pub async fn any_content_changed_of_module(
         .completed()?
         .into_inner()
         .into_postorder_topological()
-        .map(|m| source_changed(*m))
+        .map(|m| content_changed(*ResolvedVc::upcast(m)))
         .map(|v| v.to_resolved())
         .try_join()
         .await?;
@@ -85,16 +85,3 @@ pub async fn content_changed(asset: Vc<Box<dyn Asset>>) -> Result<Vc<Completion>
     asset.content().file_content().await?;
     Ok(Completion::new())
 }
-
-/// Returns a completion that changes when the content of the given asset
-/// changes.
-#[turbo_tasks::function]
-pub async fn source_changed(asset: Vc<Box<dyn Module>>) -> Result<Vc<Completion>> {
-    if let Some(source) = *asset.source().await? {
-        // Reading the file content is enough to add as dependency
-        source.content().file_content().await?;
-    } else {
-        bail!("Module {} has no source", asset.ident().to_string().await?)
-    }
-    Ok(Completion::new())
-}

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

@@ -3,6 +3,7 @@ use turbo_tasks::{ResolvedVc, Upcast, ValueToString, Vc};
 
 use super::ChunkableModule;
 use crate::{
+    asset::Asset,
     context::AssetContext,
     module::Module,
     reference_type::{EntryReferenceSubType, ReferenceType},
@@ -14,7 +15,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: Module + ChunkableModule {}
+pub trait EvaluatableAsset: Asset + Module + ChunkableModule {}
 
 pub trait EvaluatableAssetExt {
     fn to_evaluatable(

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

@@ -90,7 +90,7 @@ pub struct ModuleIds(Vec<ResolvedVc<ModuleId>>);
 
 /// A [Module] that can be converted into a [Chunk].
 #[turbo_tasks::value_trait]
-pub trait ChunkableModule: Module {
+pub trait ChunkableModule: Module + Asset {
     #[turbo_tasks::function]
     fn as_chunk_item(
         self: Vc<Self>,
@@ -115,7 +115,7 @@ impl ChunkableModules {
 // with other module types (as a MergeableModule cannot prevent itself from being merged with other
 // module types)
 #[turbo_tasks::value_trait]
-pub trait MergeableModule: Module {
+pub trait MergeableModule: Module + Asset {
     /// Even though MergeableModule is implemented, this allows a dynamic condition to determine
     /// mergeability
     #[turbo_tasks::function]

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

@@ -33,12 +33,8 @@ impl Introspectable for IntrospectableModule {
     }
 
     #[turbo_tasks::function]
-    async fn details(&self) -> Result<Vc<RcStr>> {
-        if let Some(source) = *self.0.source().await? {
-            Ok(content_to_details(source.content()))
-        } else {
-            Ok(Vc::cell("No source".into()))
-        }
+    fn details(&self) -> Vc<RcStr> {
+        content_to_details(self.0.content())
     }
 
     #[turbo_tasks::function]