From 3ec1dd2ddd6762c5e400c7e89b5b50810ffdcf31 Mon Sep 17 00:00:00 2001 From: Tobias Koppers Date: Tue, 18 Jul 2023 13:37:38 +0000 Subject: [PATCH 1/3] OutputAsset::references() returns OutputAssets --- .../src/ecmascript/node/chunk.rs | 23 ++--- .../src/ecmascript/node/entry/chunk.rs | 29 ++---- .../src/ecmascript/node/entry/runtime.rs | 50 +---------- crates/turbopack-core/src/changed.rs | 7 +- crates/turbopack-core/src/chunk/data.rs | 22 ++--- crates/turbopack-core/src/chunk/mod.rs | 4 +- crates/turbopack-core/src/introspect/asset.rs | 17 +++- crates/turbopack-core/src/output.rs | 9 +- crates/turbopack-core/src/proxied_asset.rs | 5 +- crates/turbopack-core/src/reference/mod.rs | 89 ------------------- crates/turbopack-core/src/source_map/mod.rs | 2 +- .../src/source_map/source_map_asset.rs | 37 -------- crates/turbopack-css/src/chunk/mod.rs | 51 +++++------ .../src/chunk/single_item_chunk/chunk.rs | 11 +-- .../src/chunk/single_item_chunk/mod.rs | 1 - .../src/chunk/single_item_chunk/reference.rs | 46 ---------- .../src/chunk/single_item_chunk/source_map.rs | 41 +-------- crates/turbopack-css/src/chunk/source_map.rs | 41 +-------- crates/turbopack-css/src/embed.rs | 5 +- crates/turbopack-dev-server/src/html.rs | 12 +-- .../src/source/asset_graph.rs | 7 +- crates/turbopack-dev/src/ecmascript/chunk.rs | 27 +++--- .../src/ecmascript/evaluate/chunk.rs | 14 +-- .../src/ecmascript/list/asset.rs | 16 +--- crates/turbopack-ecmascript/src/chunk/mod.rs | 21 +++-- .../src/manifest/chunk_item.rs | 8 +- .../src/manifest/loader_item.rs | 16 +++- crates/turbopack-node/src/bootstrap.rs | 13 +-- crates/turbopack-node/src/lib.rs | 4 +- .../src/render/rendered_source.rs | 28 +----- crates/turbopack-static/src/lib.rs | 12 +-- crates/turbopack-tests/tests/snapshot.rs | 4 +- crates/turbopack/src/graph/mod.rs | 8 +- crates/turbopack/src/lib.rs | 3 +- crates/turbopack/src/rebase/mod.rs | 66 ++------------ 35 files changed, 175 insertions(+), 574 deletions(-) delete mode 100644 crates/turbopack-css/src/chunk/single_item_chunk/reference.rs diff --git a/crates/turbopack-build/src/ecmascript/node/chunk.rs b/crates/turbopack-build/src/ecmascript/node/chunk.rs index a02d464e01d1f..8ee2644c50c38 100644 --- a/crates/turbopack-build/src/ecmascript/node/chunk.rs +++ b/crates/turbopack-build/src/ecmascript/node/chunk.rs @@ -6,9 +6,8 @@ use turbopack_core::{ chunk::{Chunk, ChunkingContext}, ident::AssetIdent, introspect::{Introspectable, IntrospectableChildren}, - output::OutputAsset, - reference::AssetReferences, - source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAssetReference}, + output::{OutputAsset, OutputAssets}, + source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAsset}, }; use turbopack_ecmascript::chunk::EcmascriptChunk; @@ -70,21 +69,23 @@ impl OutputAsset for EcmascriptBuildNodeChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let chunk_references = this.chunk.references().await?; - let mut references = Vec::with_capacity(chunk_references.len() + 1); + let include_source_map = *this + .chunking_context + .reference_chunk_source_maps(Vc::upcast(self)) + .await?; + let mut references = Vec::with_capacity( + chunk_references.len() + include_source_map.then_some(1).unwrap_or(0), + ); for reference in &*chunk_references { references.push(*reference); } - if *this - .chunking_context - .reference_chunk_source_maps(Vc::upcast(self)) - .await? - { - references.push(Vc::upcast(SourceMapAssetReference::new(Vc::upcast(self)))); + if include_source_map { + references.push(Vc::upcast(SourceMapAsset::new(Vc::upcast(self)))); } Ok(Vc::cell(references)) diff --git a/crates/turbopack-build/src/ecmascript/node/entry/chunk.rs b/crates/turbopack-build/src/ecmascript/node/entry/chunk.rs index f2dac40bb83cc..fbb050889d9d0 100644 --- a/crates/turbopack-build/src/ecmascript/node/entry/chunk.rs +++ b/crates/turbopack-build/src/ecmascript/node/entry/chunk.rs @@ -10,15 +10,14 @@ use turbopack_core::{ code_builder::{Code, CodeBuilder}, ident::AssetIdent, output::{OutputAsset, OutputAssets}, - reference::{AssetReferences, SingleAssetReference}, - source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAssetReference}, + source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAsset}, }; use turbopack_ecmascript::{ chunk::{EcmascriptChunkItemExt, EcmascriptChunkPlaceable}, utils::StringifyJs, }; -use super::runtime::EcmascriptBuildNodeRuntimeReference; +use super::runtime::EcmascriptBuildNodeRuntimeChunk; use crate::BuildChunkingContext; /// An Ecmascript chunk that loads a list of parallel chunks, then instantiates @@ -60,12 +59,7 @@ impl EcmascriptBuildNodeEntryChunk { let output_root = this.chunking_context.output_root().await?; let chunk_path = self.ident().path().await?; let chunk_directory = self.ident().path().parent().await?; - let runtime_path = self - .runtime_reference() - .runtime_chunk() - .ident() - .path() - .await?; + let runtime_path = self.runtime_chunk().ident().path().await?; let runtime_relative_path = if let Some(path) = chunk_directory.get_relative_path_to(&runtime_path) { path @@ -153,11 +147,9 @@ impl EcmascriptBuildNodeEntryChunk { } #[turbo_tasks::function] - async fn runtime_reference(self: Vc) -> Result> { + async fn runtime_chunk(self: Vc) -> Result> { let this = self.await?; - Ok(EcmascriptBuildNodeRuntimeReference::new( - this.chunking_context, - )) + Ok(EcmascriptBuildNodeRuntimeChunk::new(this.chunking_context)) } } @@ -187,24 +179,21 @@ impl OutputAsset for EcmascriptBuildNodeEntryChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; - let mut references = vec![Vc::upcast(self.runtime_reference())]; + let mut references = vec![Vc::upcast(self.runtime_chunk())]; if *this .chunking_context .reference_chunk_source_maps(Vc::upcast(self)) .await? { - references.push(Vc::upcast(SourceMapAssetReference::new(Vc::upcast(self)))) + references.push(Vc::upcast(SourceMapAsset::new(Vc::upcast(self)))) } let other_chunks = this.other_chunks.await?; for &other_chunk in &*other_chunks { - references.push(Vc::upcast(SingleAssetReference::new( - Vc::upcast(other_chunk), - chunk_reference_description(), - ))); + references.push(Vc::upcast(other_chunk)); } Ok(Vc::cell(references)) diff --git a/crates/turbopack-build/src/ecmascript/node/entry/runtime.rs b/crates/turbopack-build/src/ecmascript/node/entry/runtime.rs index 1c36bfb73fbf2..e28f2242f46bf 100644 --- a/crates/turbopack-build/src/ecmascript/node/entry/runtime.rs +++ b/crates/turbopack-build/src/ecmascript/node/entry/runtime.rs @@ -9,10 +9,8 @@ use turbopack_core::{ chunk::ChunkingContext, code_builder::{Code, CodeBuilder}, ident::AssetIdent, - output::OutputAsset, - reference::{AssetReference, AssetReferences}, - resolve::ResolveResult, - source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAssetReference}, + output::{OutputAsset, OutputAssets}, + source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAsset}, }; use turbopack_ecmascript::utils::StringifyJs; use turbopack_ecmascript_runtime::RuntimeType; @@ -99,7 +97,7 @@ impl OutputAsset for EcmascriptBuildNodeRuntimeChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let mut references = vec![]; @@ -108,7 +106,7 @@ impl OutputAsset for EcmascriptBuildNodeRuntimeChunk { .reference_chunk_source_maps(Vc::upcast(self)) .await? { - references.push(Vc::upcast(SourceMapAssetReference::new(Vc::upcast(self)))) + references.push(Vc::upcast(SourceMapAsset::new(Vc::upcast(self)))) } Ok(Vc::cell(references)) @@ -133,43 +131,3 @@ impl GenerateSourceMap for EcmascriptBuildNodeRuntimeChunk { self.code().generate_source_map() } } - -/// A reference to the runtime chunk. -#[turbo_tasks::value] -pub(crate) struct EcmascriptBuildNodeRuntimeReference { - chunking_context: Vc, -} - -#[turbo_tasks::value_impl] -impl EcmascriptBuildNodeRuntimeReference { - #[turbo_tasks::function] - pub fn new(chunking_context: Vc) -> Vc { - Self::cell(EcmascriptBuildNodeRuntimeReference { chunking_context }) - } - - #[turbo_tasks::function] - pub async fn runtime_chunk(self: Vc) -> Result> { - Ok(EcmascriptBuildNodeRuntimeChunk::new( - self.await?.chunking_context, - )) - } -} - -#[turbo_tasks::value_impl] -impl AssetReference for EcmascriptBuildNodeRuntimeReference { - #[turbo_tasks::function] - fn resolve_reference(self: Vc) -> Vc { - ResolveResult::asset(Vc::upcast(self.runtime_chunk())).into() - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for EcmascriptBuildNodeRuntimeReference { - #[turbo_tasks::function] - async fn to_string(self: Vc) -> Result> { - Ok(Vc::cell(format!( - "runtime chunk {}", - self.runtime_chunk().ident().to_string().await? - ))) - } -} diff --git a/crates/turbopack-core/src/changed.rs b/crates/turbopack-core/src/changed.rs index b541eba648265..0254ecbde1ad1 100644 --- a/crates/turbopack-core/src/changed.rs +++ b/crates/turbopack-core/src/changed.rs @@ -8,16 +8,13 @@ use crate::{ asset::Asset, module::Module, output::{OutputAsset, OutputAssets}, - reference::{all_referenced_modules, all_referenced_output_assets}, + reference::all_referenced_modules, }; async fn get_referenced_output_assets( parent: Vc>, ) -> Result>> + Send> { - Ok(all_referenced_output_assets(parent) - .await? - .clone_value() - .into_iter()) + Ok(parent.references().await?.clone_value().into_iter()) } async fn get_referenced_modules( diff --git a/crates/turbopack-core/src/chunk/data.rs b/crates/turbopack-core/src/chunk/data.rs index 03becef4c3333..9dd8de750578a 100644 --- a/crates/turbopack-core/src/chunk/data.rs +++ b/crates/turbopack-core/src/chunk/data.rs @@ -5,7 +5,6 @@ use turbo_tasks_fs::FileSystemPath; use crate::{ chunk::{ModuleId, OutputChunk, OutputChunkRuntimeInfo}, output::{OutputAsset, OutputAssets}, - reference::{AssetReferences, SingleAssetReference}, }; #[turbo_tasks::value] @@ -14,7 +13,7 @@ pub struct ChunkData { pub included: Vec>, pub excluded: Vec>, pub module_chunks: Vec, - pub references: Vc, + pub references: Vc, } #[turbo_tasks::value(transparent)] @@ -57,7 +56,7 @@ impl ChunkData { included: Vec::new(), excluded: Vec::new(), module_chunks: Vec::new(), - references: AssetReferences::empty(), + references: OutputAssets::empty(), } .cell(), ))); @@ -92,15 +91,9 @@ impl ChunkData { async move { let chunk_path = chunk.ident().path().await?; - Ok(output_root.get_path_to(&chunk_path).map(|path| { - ( - path.to_owned(), - Vc::upcast(SingleAssetReference::new( - Vc::upcast(chunk), - module_chunk_reference_description(), - )), - ) - })) + Ok(output_root + .get_path_to(&chunk_path) + .map(|path| (path.to_owned(), chunk))) } }) .try_join() @@ -142,10 +135,9 @@ impl ChunkData { )) } - /// Returns [`AssetReferences`] to the assets that this chunk data - /// references. + /// Returns [`OutputAsset`]s that this chunk data references. #[turbo_tasks::function] - pub async fn references(self: Vc) -> Result> { + pub async fn references(self: Vc) -> Result> { Ok(self.await?.references) } } diff --git a/crates/turbopack-core/src/chunk/mod.rs b/crates/turbopack-core/src/chunk/mod.rs index 7a2c28a551ce8..b96f746279460 100644 --- a/crates/turbopack-core/src/chunk/mod.rs +++ b/crates/turbopack-core/src/chunk/mod.rs @@ -135,8 +135,8 @@ pub trait Chunk: Asset { /// Other things (most likely [Asset]s) referenced from this [Chunk]. // TODO refactor this to ensure that only [OutputAsset]s can be referenced - fn references(self: Vc) -> Vc { - AssetReferences::empty() + fn references(self: Vc) -> Vc { + OutputAssets::empty() } } diff --git a/crates/turbopack-core/src/introspect/asset.rs b/crates/turbopack-core/src/introspect/asset.rs index 3a888b4b8e37b..16eb2f0f88a2e 100644 --- a/crates/turbopack-core/src/introspect/asset.rs +++ b/crates/turbopack-core/src/introspect/asset.rs @@ -8,7 +8,7 @@ use crate::{ asset::{Asset, AssetContent}, chunk::{ChunkableModuleReference, ChunkingType}, module::Module, - output::OutputAsset, + output::{OutputAsset, OutputAssets}, reference::{AssetReference, AssetReferences}, resolve::PrimaryResolveResult, source::Source, @@ -106,7 +106,7 @@ impl Introspectable for IntrospectableAsset { } else if let Some(output_asset) = Vc::try_resolve_downcast::>(asset).await? { - children_from_asset_references(output_asset.references()) + children_from_output_assets(output_asset.references()) } else { bail!("unknown type") }, @@ -163,3 +163,16 @@ pub async fn children_from_asset_references( } Ok(Vc::cell(children)) } + +#[turbo_tasks::function] +pub async fn children_from_output_assets( + references: Vc, +) -> Result> { + let key = reference_ty(); + let mut children = IndexSet::new(); + let references = references.await?; + for &reference in &*references { + children.insert((key, IntrospectableAsset::new(Vc::upcast(reference)))); + } + Ok(Vc::cell(children)) +} diff --git a/crates/turbopack-core/src/output.rs b/crates/turbopack-core/src/output.rs index 051cbce344b2a..a467023dec284 100644 --- a/crates/turbopack-core/src/output.rs +++ b/crates/turbopack-core/src/output.rs @@ -2,7 +2,7 @@ use anyhow::{Context, Result}; use indexmap::IndexSet; use turbo_tasks::Vc; -use crate::{asset::Asset, ident::AssetIdent, reference::AssetReferences}; +use crate::{asset::Asset, ident::AssetIdent}; /// An asset that should be outputted, e. g. written to disk or served from a /// server. @@ -13,10 +13,9 @@ pub trait OutputAsset: Asset { /// capture all properties of the [OutputAsset]. Only path must be used. fn ident(&self) -> Vc; - /// Other things (most likely [Asset]s) referenced from this [OutputAsset]. - // TODO refactor this to ensure that only [OutputAsset]s can be referenced - fn references(self: Vc) -> Vc { - AssetReferences::empty() + /// Other references [OutputAsset]s from this [OutputAsset]. + fn references(self: Vc) -> Vc { + OutputAssets::empty() } } diff --git a/crates/turbopack-core/src/proxied_asset.rs b/crates/turbopack-core/src/proxied_asset.rs index 247e728c7b7ac..d110a98c992ae 100644 --- a/crates/turbopack-core/src/proxied_asset.rs +++ b/crates/turbopack-core/src/proxied_asset.rs @@ -4,8 +4,7 @@ use turbo_tasks_fs::FileSystemPath; use crate::{ asset::{Asset, AssetContent}, ident::AssetIdent, - output::OutputAsset, - reference::AssetReferences, + output::{OutputAsset, OutputAssets}, version::VersionedContent, }; @@ -36,7 +35,7 @@ impl OutputAsset for ProxiedAsset { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.asset.references() } } diff --git a/crates/turbopack-core/src/reference/mod.rs b/crates/turbopack-core/src/reference/mod.rs index 88a0c2002fec6..ae2900651336c 100644 --- a/crates/turbopack-core/src/reference/mod.rs +++ b/crates/turbopack-core/src/reference/mod.rs @@ -7,7 +7,6 @@ use crate::{ asset::Asset, issue::IssueContextExt, module::{convert_asset_to_module, Module, Modules}, - output::{OutputAsset, OutputAssets}, resolve::{PrimaryResolveResult, ResolveResult}, }; pub mod source_map; @@ -86,52 +85,6 @@ impl SingleAssetReference { } } -/// Aggregates all [Asset]s referenced by an [Asset]. [AssetReference] -/// This does not include transitively references [Asset]s, but it includes -/// primary and secondary [Asset]s referenced. -/// -/// [Asset]: crate::asset::Asset -#[turbo_tasks::function] -pub async fn all_referenced_output_assets( - asset: Vc>, -) -> Result> { - let references_set = asset.references().await?; - let mut assets = Vec::new(); - let mut queue = VecDeque::with_capacity(32); - for reference in references_set.iter() { - queue.push_back(reference.resolve_reference()); - } - // that would be non-deterministic: - // while let Some(result) = race_pop(&mut queue).await { - // match &*result? { - while let Some(resolve_result) = queue.pop_front() { - let ResolveResult { - primary, - references, - } = &*resolve_result.await?; - for result in primary { - if let PrimaryResolveResult::Asset(asset) = *result { - assets.push(asset); - } - } - for reference in references { - queue.push_back(reference.resolve_reference()); - } - } - let output_assets = - assets - .into_iter() - .map(|asset| async move { - Ok(Vc::try_resolve_downcast::>(asset).await?) - }) - .try_join() - .await? - .into_iter() - .flatten() - .collect(); - Ok(Vc::cell(output_assets)) -} - /// Aggregates all [Asset]s referenced by an [Asset]. [AssetReference] /// This does not include transitively references [Asset]s, but it includes /// primary and secondary [Asset]s referenced. @@ -203,48 +156,6 @@ pub async fn primary_referenced_modules(module: Vc>) -> Result>, -) -> Result> { - let output_assets = - output_asset - .references() - .await? - .iter() - .map(|reference| async { - let ResolveResult { primary, .. } = &*reference.resolve_reference().await?; - Ok(primary - .iter() - .filter_map(|result| { - if let PrimaryResolveResult::Asset(asset) = *result { - Some(asset) - } else { - None - } - }) - .collect::>()) - }) - .try_join() - .await? - .into_iter() - .flatten() - .map(|asset| async move { - Ok(Vc::try_resolve_downcast::>(asset).await?) - }) - .try_join() - .await? - .into_iter() - .flatten() - .collect(); - Ok(Vc::cell(output_assets)) -} - /// Aggregates all [Module]s referenced by an [Module] including transitively /// referenced [Module]s. This basically gives all [Module]s in a subgraph /// starting from the passed [Module]. diff --git a/crates/turbopack-core/src/source_map/mod.rs b/crates/turbopack-core/src/source_map/mod.rs index f00dd96c2b458..62e0d11357315 100644 --- a/crates/turbopack-core/src/source_map/mod.rs +++ b/crates/turbopack-core/src/source_map/mod.rs @@ -11,7 +11,7 @@ use crate::source_pos::SourcePos; pub(crate) mod source_map_asset; -pub use source_map_asset::SourceMapAssetReference; +pub use source_map_asset::SourceMapAsset; /// Allows callers to generate source maps. #[turbo_tasks::value_trait] diff --git a/crates/turbopack-core/src/source_map/source_map_asset.rs b/crates/turbopack-core/src/source_map/source_map_asset.rs index ffbafd905545e..ab66b6f8a93ed 100644 --- a/crates/turbopack-core/src/source_map/source_map_asset.rs +++ b/crates/turbopack-core/src/source_map/source_map_asset.rs @@ -8,8 +8,6 @@ use crate::{ ident::AssetIdent, introspect::{Introspectable, IntrospectableChildren}, output::OutputAsset, - reference::AssetReference, - resolve::ResolveResult, source_map::{GenerateSourceMap, SourceMap}, }; @@ -95,38 +93,3 @@ impl Introspectable for SourceMapAsset { Ok(Vc::cell(children)) } } - -/// A reference to a [`SourceMapAsset`], used to inform the dev -/// server/build system of the presence of the source map -#[turbo_tasks::value] -pub struct SourceMapAssetReference { - asset: Vc>, -} - -#[turbo_tasks::value_impl] -impl SourceMapAssetReference { - #[turbo_tasks::function] - pub fn new(asset: Vc>) -> Vc { - SourceMapAssetReference { asset }.cell() - } -} - -#[turbo_tasks::value_impl] -impl AssetReference for SourceMapAssetReference { - #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { - let asset = Vc::upcast(SourceMapAsset::new(self.asset)); - Ok(ResolveResult::asset(asset).cell()) - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for SourceMapAssetReference { - #[turbo_tasks::function] - async fn to_string(&self) -> Result> { - Ok(Vc::cell(format!( - "source map for {}", - self.asset.ident().path().to_string().await? - ))) - } -} diff --git a/crates/turbopack-css/src/chunk/mod.rs b/crates/turbopack-css/src/chunk/mod.rs index 87f2a2357acf0..4dc9e43d5accc 100644 --- a/crates/turbopack-css/src/chunk/mod.rs +++ b/crates/turbopack-css/src/chunk/mod.rs @@ -18,21 +18,17 @@ use turbopack_core::{ code_builder::{Code, CodeBuilder}, ident::AssetIdent, introspect::{ - asset::{children_from_asset_references, content_to_details, IntrospectableAsset}, + asset::{children_from_output_assets, content_to_details, IntrospectableAsset}, Introspectable, IntrospectableChildren, }, module::Module, - output::OutputAsset, - reference::{AssetReference, AssetReferences}, - resolve::PrimaryResolveResult, + output::{OutputAsset, OutputAssets}, + reference::AssetReference, source_map::{GenerateSourceMap, OptionSourceMap}, }; use writer::expand_imports; -use self::{ - single_item_chunk::{chunk::SingleItemCssChunk, reference::SingleItemCssChunkReference}, - source_map::CssChunkSourceMapAssetReference, -}; +use self::{single_item_chunk::chunk::SingleItemCssChunk, source_map::CssChunkSourceMapAsset}; use crate::{ embed::{CssEmbed, CssEmbeddable}, parse::ParseCssResultSourceMap, @@ -297,7 +293,7 @@ impl Chunk for CssChunk { } #[turbo_tasks::function] - fn references(self: Vc) -> Vc { + fn references(self: Vc) -> Vc { OutputAsset::references(self) } } @@ -392,7 +388,7 @@ impl OutputAsset for CssChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let content = css_chunk_content( this.context, @@ -401,31 +397,32 @@ impl OutputAsset for CssChunk { ) .await?; let mut references = Vec::new(); - for r in content.external_asset_references.iter() { - references.push(*r); - for result in r.resolve_reference().await?.primary.iter() { - if let PrimaryResolveResult::Asset(asset) = result { - if let Some(embeddable) = - Vc::try_resolve_sidecast::>(*asset).await? - { - let embed = embeddable.as_css_embed(this.context); - references.extend(embed.references().await?.iter()); - } - } + let assets = content + .external_asset_references + .iter() + .map(|r| r.resolve_reference().primary_assets()) + .try_join() + .await?; + for &asset in assets.iter().flatten() { + if let Some(output_asset) = Vc::try_resolve_downcast(asset).await? { + references.push(output_asset); + } + if let Some(embeddable) = + Vc::try_resolve_sidecast::>(asset).await? + { + let embed = embeddable.as_css_embed(this.context); + references.extend(embed.references().await?.iter()); } } for item in content.chunk_items.iter() { - references.push(Vc::upcast(SingleItemCssChunkReference::new( - this.context, - *item, - ))); + references.push(Vc::upcast(SingleItemCssChunk::new(this.context, *item))); } if *this .context .reference_chunk_source_maps(Vc::upcast(self)) .await? { - references.push(Vc::upcast(CssChunkSourceMapAssetReference::new(self))); + references.push(Vc::upcast(CssChunkSourceMapAsset::new(self))); } Ok(Vc::cell(references)) } @@ -575,7 +572,7 @@ impl Introspectable for CssChunk { #[turbo_tasks::function] async fn children(self: Vc) -> Result> { - let mut children = children_from_asset_references(OutputAsset::references(self)) + let mut children = children_from_output_assets(OutputAsset::references(self)) .await? .clone_value(); for &entry in &*self.await?.main_entries.await? { diff --git a/crates/turbopack-css/src/chunk/single_item_chunk/chunk.rs b/crates/turbopack-css/src/chunk/single_item_chunk/chunk.rs index a525cda460bb0..776e424a3b642 100644 --- a/crates/turbopack-css/src/chunk/single_item_chunk/chunk.rs +++ b/crates/turbopack-css/src/chunk/single_item_chunk/chunk.rs @@ -9,12 +9,11 @@ use turbopack_core::{ code_builder::{Code, CodeBuilder}, ident::AssetIdent, introspect::Introspectable, - output::OutputAsset, - reference::AssetReferences, + output::{OutputAsset, OutputAssets}, source_map::{GenerateSourceMap, OptionSourceMap}, }; -use super::source_map::SingleItemCssChunkSourceMapAssetReference; +use super::source_map::SingleItemCssChunkSourceMapAsset; use crate::chunk::CssChunkItem; /// A CSS chunk that only contains a single item. This is used for selectively @@ -103,7 +102,7 @@ impl OutputAsset for SingleItemCssChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let mut references = Vec::new(); if *this @@ -111,9 +110,7 @@ impl OutputAsset for SingleItemCssChunk { .reference_chunk_source_maps(Vc::upcast(self)) .await? { - references.push(Vc::upcast(SingleItemCssChunkSourceMapAssetReference::new( - self, - ))); + references.push(Vc::upcast(SingleItemCssChunkSourceMapAsset::new(self))); } Ok(Vc::cell(references)) } diff --git a/crates/turbopack-css/src/chunk/single_item_chunk/mod.rs b/crates/turbopack-css/src/chunk/single_item_chunk/mod.rs index 1eff41e52d426..9950d4389711d 100644 --- a/crates/turbopack-css/src/chunk/single_item_chunk/mod.rs +++ b/crates/turbopack-css/src/chunk/single_item_chunk/mod.rs @@ -1,3 +1,2 @@ pub(crate) mod chunk; -pub(crate) mod reference; pub(crate) mod source_map; diff --git a/crates/turbopack-css/src/chunk/single_item_chunk/reference.rs b/crates/turbopack-css/src/chunk/single_item_chunk/reference.rs deleted file mode 100644 index a367add19341b..0000000000000 --- a/crates/turbopack-css/src/chunk/single_item_chunk/reference.rs +++ /dev/null @@ -1,46 +0,0 @@ -use anyhow::Result; -use turbo_tasks::{ValueToString, Vc}; -use turbopack_core::{ - chunk::{ChunkItem, ChunkingContext}, - reference::AssetReference, - resolve::ResolveResult, -}; - -use super::chunk::SingleItemCssChunk; -use crate::chunk::CssChunkItem; - -/// A reference to a [`Vc`]. -#[turbo_tasks::value] -#[derive(Hash, Debug)] -pub struct SingleItemCssChunkReference { - context: Vc>, - item: Vc>, -} - -#[turbo_tasks::value_impl] -impl SingleItemCssChunkReference { - /// Creates a new [`Vc`]. - #[turbo_tasks::function] - pub fn new(context: Vc>, item: Vc>) -> Vc { - Self::cell(SingleItemCssChunkReference { context, item }) - } -} - -#[turbo_tasks::value_impl] -impl AssetReference for SingleItemCssChunkReference { - #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(SingleItemCssChunk::new(self.context, self.item))).cell() - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for SingleItemCssChunkReference { - #[turbo_tasks::function] - async fn to_string(&self) -> Result> { - Ok(Vc::cell(format!( - "css single item chunk {}", - self.item.asset_ident().to_string().await? - ))) - } -} diff --git a/crates/turbopack-css/src/chunk/single_item_chunk/source_map.rs b/crates/turbopack-css/src/chunk/single_item_chunk/source_map.rs index ab9875e352afb..2706cac561f90 100644 --- a/crates/turbopack-css/src/chunk/single_item_chunk/source_map.rs +++ b/crates/turbopack-css/src/chunk/single_item_chunk/source_map.rs @@ -1,13 +1,11 @@ use anyhow::Result; -use turbo_tasks::{ValueToString, Vc}; +use turbo_tasks::Vc; use turbo_tasks_fs::File; use turbopack_core::{ asset::{Asset, AssetContent}, chunk::Chunk, ident::AssetIdent, output::OutputAsset, - reference::AssetReference, - resolve::ResolveResult, source_map::{GenerateSourceMap, SourceMap}, }; @@ -50,40 +48,3 @@ impl Asset for SingleItemCssChunkSourceMapAsset { Ok(AssetContent::file(File::from(sm).into())) } } - -/// A reference to a [`SingleItemCssChunkSourceMapAsset`], used to inform the -/// dev server/build system of the presence of the source map -#[turbo_tasks::value] -pub struct SingleItemCssChunkSourceMapAssetReference { - chunk: Vc, -} - -#[turbo_tasks::value_impl] -impl SingleItemCssChunkSourceMapAssetReference { - #[turbo_tasks::function] - pub fn new(chunk: Vc) -> Vc { - SingleItemCssChunkSourceMapAssetReference { chunk }.cell() - } -} - -#[turbo_tasks::value_impl] -impl AssetReference for SingleItemCssChunkSourceMapAssetReference { - #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { - let source_maps = vec![Vc::upcast( - SingleItemCssChunkSourceMapAsset { chunk: self.chunk }.cell(), - )]; - Ok(ResolveResult::assets_with_references(source_maps, vec![]).cell()) - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for SingleItemCssChunkSourceMapAssetReference { - #[turbo_tasks::function] - async fn to_string(&self) -> Result> { - Ok(Vc::cell(format!( - "source maps for {}", - self.chunk.path().to_string().await? - ))) - } -} diff --git a/crates/turbopack-css/src/chunk/source_map.rs b/crates/turbopack-css/src/chunk/source_map.rs index 14fabe9d3ccd1..854dd0c2c869a 100644 --- a/crates/turbopack-css/src/chunk/source_map.rs +++ b/crates/turbopack-css/src/chunk/source_map.rs @@ -1,13 +1,11 @@ use anyhow::Result; -use turbo_tasks::{ValueToString, Vc}; +use turbo_tasks::Vc; use turbo_tasks_fs::File; use turbopack_core::{ asset::{Asset, AssetContent}, chunk::Chunk, ident::AssetIdent, output::OutputAsset, - reference::AssetReference, - resolve::ResolveResult, source_map::{GenerateSourceMap, SourceMap}, }; @@ -50,40 +48,3 @@ impl Asset for CssChunkSourceMapAsset { Ok(AssetContent::file(File::from(sm).into())) } } - -/// A reference to a [`CssChunkSourceMapAsset`], used to inform the dev -/// server/build system of the presence of the source map -#[turbo_tasks::value] -pub struct CssChunkSourceMapAssetReference { - chunk: Vc, -} - -#[turbo_tasks::value_impl] -impl CssChunkSourceMapAssetReference { - #[turbo_tasks::function] - pub fn new(chunk: Vc) -> Vc { - CssChunkSourceMapAssetReference { chunk }.cell() - } -} - -#[turbo_tasks::value_impl] -impl AssetReference for CssChunkSourceMapAssetReference { - #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { - let source_maps = vec![Vc::upcast( - CssChunkSourceMapAsset { chunk: self.chunk }.cell(), - )]; - Ok(ResolveResult::assets_with_references(source_maps, vec![]).cell()) - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for CssChunkSourceMapAssetReference { - #[turbo_tasks::function] - async fn to_string(&self) -> Result> { - Ok(Vc::cell(format!( - "source maps for {}", - self.chunk.path().to_string().await? - ))) - } -} diff --git a/crates/turbopack-css/src/embed.rs b/crates/turbopack-css/src/embed.rs index c797e4d4c6098..995544c9350b3 100644 --- a/crates/turbopack-css/src/embed.rs +++ b/crates/turbopack-css/src/embed.rs @@ -3,8 +3,7 @@ use turbopack_core::{ asset::Asset, chunk::{ChunkableModule, ChunkingContext}, module::Module, - output::OutputAsset, - reference::AssetReferences, + output::{OutputAsset, OutputAssets}, }; #[turbo_tasks::value_trait] @@ -19,6 +18,6 @@ pub trait CssEmbed { /// [Asset]. /// TODO(alexkirsz) This should have a default impl that returns empty /// references. - fn references(self: Vc) -> Vc; + fn references(self: Vc) -> Vc; fn embeddable_asset(self: Vc) -> Vc>; } diff --git a/crates/turbopack-dev-server/src/html.rs b/crates/turbopack-dev-server/src/html.rs index 17a2a82b19c7b..46725262d134b 100644 --- a/crates/turbopack-dev-server/src/html.rs +++ b/crates/turbopack-dev-server/src/html.rs @@ -8,7 +8,6 @@ use turbopack_core::{ chunk::{ChunkableModule, ChunkingContext, EvaluatableAssets}, ident::AssetIdent, output::{OutputAsset, OutputAssets}, - reference::{AssetReferences, SingleAssetReference}, version::{Version, VersionedContent}, }; @@ -44,15 +43,8 @@ impl OutputAsset for DevHtmlAsset { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { - let mut references = Vec::new(); - for &chunk in &*self.chunks().await? { - references.push(Vc::upcast(SingleAssetReference::new( - Vc::upcast(chunk), - dev_html_chunk_reference_description(), - ))); - } - Ok(Vc::cell(references)) + fn references(self: Vc) -> Vc { + self.chunks() } } diff --git a/crates/turbopack-dev-server/src/source/asset_graph.rs b/crates/turbopack-dev-server/src/source/asset_graph.rs index a5dad568fce48..8c798dabf0413 100644 --- a/crates/turbopack-dev-server/src/source/asset_graph.rs +++ b/crates/turbopack-dev-server/src/source/asset_graph.rs @@ -11,7 +11,6 @@ use turbopack_core::{ asset::Asset, introspect::{asset::IntrospectableAsset, Introspectable, IntrospectableChildren}, output::{OutputAsset, OutputAssetsSet}, - reference::all_referenced_output_assets, }; use super::{ @@ -118,14 +117,14 @@ async fn expand( assets.push((root_asset.ident().path(), *root_asset)); assets_set.insert(*root_asset); if expanded { - queue.push_back(all_referenced_output_assets(*root_asset)); + queue.push_back(root_asset.references()); } } } else { for root_asset in root_assets.iter() { assets.push((root_asset.ident().path(), *root_asset)); assets_set.insert(*root_asset); - queue.push_back(all_referenced_output_assets(*root_asset)); + queue.push_back(root_asset.references()); } } @@ -142,7 +141,7 @@ async fn expand( true }; if expanded { - queue.push_back(all_referenced_output_assets(*asset)); + queue.push_back(asset.references()); } assets.push((asset.ident().path(), *asset)); } diff --git a/crates/turbopack-dev/src/ecmascript/chunk.rs b/crates/turbopack-dev/src/ecmascript/chunk.rs index fe62db1ac0048..932a04bbe2d48 100644 --- a/crates/turbopack-dev/src/ecmascript/chunk.rs +++ b/crates/turbopack-dev/src/ecmascript/chunk.rs @@ -6,9 +6,8 @@ use turbopack_core::{ chunk::{Chunk, ChunkingContext, OutputChunk, OutputChunkRuntimeInfo}, ident::AssetIdent, introspect::{Introspectable, IntrospectableChildren}, - output::OutputAsset, - reference::AssetReferences, - source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAssetReference}, + output::{OutputAsset, OutputAssets}, + source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAsset}, version::VersionedContent, }; use turbopack_ecmascript::chunk::EcmascriptChunk; @@ -82,21 +81,21 @@ impl OutputAsset for EcmascriptDevChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let chunk_references = this.chunk.references().await?; - let mut references = Vec::with_capacity(chunk_references.len() + 1); - - for reference in &*chunk_references { - references.push(*reference); - } - - if *this + let include_source_map = *this .chunking_context .reference_chunk_source_maps(Vc::upcast(self)) - .await? - { - references.push(Vc::upcast(SourceMapAssetReference::new(Vc::upcast(self)))); + .await?; + let mut references = Vec::with_capacity( + chunk_references.len() + include_source_map.then_some(1).unwrap_or(0), + ); + + references.extend(chunk_references.iter().copied()); + + if include_source_map { + references.push(Vc::upcast(SourceMapAsset::new(Vc::upcast(self)))); } Ok(Vc::cell(references)) diff --git a/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs b/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs index 8f1e86113f933..38d76e744e8d9 100644 --- a/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs +++ b/crates/turbopack-dev/src/ecmascript/evaluate/chunk.rs @@ -12,8 +12,7 @@ use turbopack_core::{ ident::AssetIdent, module::Module, output::{OutputAsset, OutputAssets}, - reference::AssetReferences, - source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAssetReference}, + source_map::{GenerateSourceMap, OptionSourceMap, SourceMapAsset}, }; use turbopack_ecmascript::{ chunk::{EcmascriptChunkData, EcmascriptChunkItemExt, EcmascriptChunkPlaceable}, @@ -201,16 +200,17 @@ impl OutputAsset for EcmascriptDevEvaluateChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let mut references = Vec::new(); - if *this + let include_source_map = *this .chunking_context .reference_chunk_source_maps(Vc::upcast(self)) - .await? - { - references.push(Vc::upcast(SourceMapAssetReference::new(Vc::upcast(self)))); + .await?; + + if include_source_map { + references.push(Vc::upcast(SourceMapAsset::new(Vc::upcast(self)))); } for chunk_data in &*self.chunks_data().await? { diff --git a/crates/turbopack-dev/src/ecmascript/list/asset.rs b/crates/turbopack-dev/src/ecmascript/list/asset.rs index 936e0cd9b0b86..ba2325ad3efa0 100644 --- a/crates/turbopack-dev/src/ecmascript/list/asset.rs +++ b/crates/turbopack-dev/src/ecmascript/list/asset.rs @@ -6,7 +6,6 @@ use turbopack_core::{ chunk::{Chunk, ChunkingContext}, ident::AssetIdent, output::{OutputAsset, OutputAssets}, - reference::{AssetReferences, SingleAssetReference}, version::VersionedContent, }; @@ -94,19 +93,8 @@ impl OutputAsset for EcmascriptDevChunkList { } #[turbo_tasks::function] - async fn references(&self) -> Result> { - Ok(Vc::cell( - self.chunks - .await? - .iter() - .map(|&chunk| { - Vc::upcast(SingleAssetReference::new( - Vc::upcast(chunk), - chunk_list_chunk_reference_description(), - )) - }) - .collect(), - )) + async fn references(&self) -> Result> { + Ok(self.chunks) } } diff --git a/crates/turbopack-ecmascript/src/chunk/mod.rs b/crates/turbopack-ecmascript/src/chunk/mod.rs index 296ae0e756474..c452dbdf4f558 100644 --- a/crates/turbopack-ecmascript/src/chunk/mod.rs +++ b/crates/turbopack-ecmascript/src/chunk/mod.rs @@ -17,11 +17,12 @@ use turbopack_core::{ }, ident::AssetIdent, introspect::{ - asset::{children_from_asset_references, content_to_details, IntrospectableAsset}, + asset::{children_from_output_assets, content_to_details, IntrospectableAsset}, Introspectable, IntrospectableChildren, }, module::Module, - reference::AssetReferences, + output::OutputAssets, + reference::AssetReference, }; use self::content::ecmascript_chunk_content; @@ -313,7 +314,7 @@ impl Chunk for EcmascriptChunk { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let content = ecmascript_chunk_content( this.context, @@ -323,8 +324,16 @@ impl Chunk for EcmascriptChunk { ) .await?; let mut references = Vec::new(); - for r in content.external_asset_references.iter() { - references.push(*r); + let assets = content + .external_asset_references + .iter() + .map(|r| r.resolve_reference().primary_assets()) + .try_join() + .await?; + for &asset in assets.iter().flatten() { + if let Some(output_asset) = Vc::try_resolve_downcast(asset).await? { + references.push(output_asset); + } } Ok(Vc::cell(references)) @@ -440,7 +449,7 @@ impl Introspectable for EcmascriptChunk { #[turbo_tasks::function] async fn children(self: Vc) -> Result> { - let mut children = children_from_asset_references(self.references()) + let mut children = children_from_output_assets(self.references()) .await? .clone_value(); for &entry in &*self.await?.main_entries.await? { diff --git a/crates/turbopack-ecmascript/src/manifest/chunk_item.rs b/crates/turbopack-ecmascript/src/manifest/chunk_item.rs index 4a0bf6272d8f8..90e5999aca71f 100644 --- a/crates/turbopack-ecmascript/src/manifest/chunk_item.rs +++ b/crates/turbopack-ecmascript/src/manifest/chunk_item.rs @@ -5,7 +5,7 @@ use turbopack_core::{ chunk::{ChunkData, ChunkItem, ChunkingContext, ChunksData}, ident::AssetIdent, module::Module, - reference::AssetReferences, + reference::{AssetReferences, SingleAssetReference}, }; use super::chunk_asset::ManifestChunkAsset; @@ -81,8 +81,12 @@ impl ChunkItem for ManifestChunkItem { let this = self.await?; let mut references = this.manifest.references().await?.clone_value(); + let key = Vc::cell("chunk data reference".to_string()); + for chunk_data in &*self.chunks_data().await? { - references.extend(chunk_data.references().await?.iter().copied()); + references.extend(chunk_data.references().await?.iter().map(|&output_asset| { + Vc::upcast(SingleAssetReference::new(Vc::upcast(output_asset), key)) + })); } Ok(Vc::cell(references)) diff --git a/crates/turbopack-ecmascript/src/manifest/loader_item.rs b/crates/turbopack-ecmascript/src/manifest/loader_item.rs index 0906cb164c0ae..b3703be8bf755 100644 --- a/crates/turbopack-ecmascript/src/manifest/loader_item.rs +++ b/crates/turbopack-ecmascript/src/manifest/loader_item.rs @@ -7,7 +7,7 @@ use turbopack_core::{ chunk::{ChunkData, ChunkItem, ChunkingContext, ChunksData}, ident::AssetIdent, module::Module, - reference::{AssetReferences, SingleAssetReference}, + reference::{AssetReference, AssetReferences, SingleAssetReference}, }; use super::chunk_asset::ManifestChunkAsset; @@ -65,6 +65,11 @@ fn manifest_loader_chunk_reference_description() -> Vc { Vc::cell("manifest loader chunk".to_string()) } +#[turbo_tasks::function] +fn chunk_data_reference_description() -> Vc { + Vc::cell("chunk data reference".to_string()) +} + #[turbo_tasks::value_impl] impl ChunkItem for ManifestLoaderItem { #[turbo_tasks::function] @@ -78,7 +83,7 @@ impl ChunkItem for ManifestLoaderItem { let chunks = this.manifest.manifest_chunks(); - let mut references: Vec<_> = chunks + let mut references: Vec>> = chunks .await? .iter() .map(|&chunk| { @@ -90,7 +95,12 @@ impl ChunkItem for ManifestLoaderItem { .collect(); for chunk_data in &*self.chunks_data().await? { - references.extend(chunk_data.references().await?.iter().copied()); + references.extend(chunk_data.references().await?.iter().map(|&output_asset| { + Vc::upcast(SingleAssetReference::new( + Vc::upcast(output_asset), + chunk_data_reference_description(), + )) + })); } Ok(Vc::cell(references)) diff --git a/crates/turbopack-node/src/bootstrap.rs b/crates/turbopack-node/src/bootstrap.rs index ed076799251ec..85d876003770a 100644 --- a/crates/turbopack-node/src/bootstrap.rs +++ b/crates/turbopack-node/src/bootstrap.rs @@ -8,7 +8,6 @@ use turbopack_core::{ chunk::{Chunk, ChunkingContext, EvaluatableAssets}, ident::AssetIdent, output::{OutputAsset, OutputAssets}, - reference::{AssetReferences, SingleAssetReference}, }; use turbopack_ecmascript::utils::StringifyJs; @@ -40,16 +39,8 @@ impl OutputAsset for NodeJsBootstrapAsset { } #[turbo_tasks::function] - async fn references(&self) -> Result> { - let chunks = self.chunks().await?; - let mut references = Vec::new(); - for &chunk in chunks.iter() { - references.push(Vc::upcast(SingleAssetReference::new( - Vc::upcast(chunk), - node_js_bootstrap_chunk_reference_description(), - ))); - } - Ok(Vc::cell(references)) + fn references(&self) -> Vc { + self.chunks() } } diff --git a/crates/turbopack-node/src/lib.rs b/crates/turbopack-node/src/lib.rs index 97be4a133e970..0caef15741ac7 100644 --- a/crates/turbopack-node/src/lib.rs +++ b/crates/turbopack-node/src/lib.rs @@ -21,7 +21,6 @@ use turbopack_core::{ chunk::{ChunkableModule, ChunkingContext, EvaluatableAsset, EvaluatableAssets}, module::Module, output::{OutputAsset, OutputAssetsSet}, - reference::primary_referenced_output_assets, source_map::GenerateSourceMap, virtual_output::VirtualOutputAsset, }; @@ -144,7 +143,8 @@ async fn separate_assets( let Type::Internal(asset) = asset else { return Ok(Vec::new()); }; - primary_referenced_output_assets(asset) + asset + .references() .await? .iter() .map(|asset| async { diff --git a/crates/turbopack-node/src/render/rendered_source.rs b/crates/turbopack-node/src/render/rendered_source.rs index 596511a8ccdbd..0a250008af486 100644 --- a/crates/turbopack-node/src/render/rendered_source.rs +++ b/crates/turbopack-node/src/render/rendered_source.rs @@ -1,7 +1,7 @@ use anyhow::{anyhow, Result}; use indexmap::IndexSet; use serde_json::Value as JsonValue; -use turbo_tasks::{TryJoinIterExt, Value, Vc}; +use turbo_tasks::{Value, Vc}; use turbo_tasks_env::ProcessEnv; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ @@ -9,8 +9,6 @@ use turbopack_core::{ issue::IssueContextExt, module::Module, output::OutputAsset, - reference::AssetReference, - resolve::PrimaryResolveResult, version::VersionedContentExt, }; use turbopack_dev_server::{ @@ -111,28 +109,8 @@ impl GetContentSource for NodeRenderContentSource { async fn content_source(&self) -> Result>> { let entries = self.entry.entries(); let mut set = IndexSet::new(); - for reference in self.fallback_page.references().await?.iter() { - set.extend( - reference - .resolve_reference() - .await? - .primary - .iter() - .filter_map(|result| { - if let PrimaryResolveResult::Asset(asset) = result { - Some(asset) - } else { - None - } - }) - .map(|&asset| async move { - Ok(Vc::try_resolve_downcast::>(asset).await?) - }) - .try_join() - .await? - .into_iter() - .flatten(), - ) + for &reference in self.fallback_page.references().await?.iter() { + set.insert(reference); } for &entry in entries.await?.iter() { let entry = entry.await?; diff --git a/crates/turbopack-static/src/lib.rs b/crates/turbopack-static/src/lib.rs index 87123660c9a58..08bc20ea10f1e 100644 --- a/crates/turbopack-static/src/lib.rs +++ b/crates/turbopack-static/src/lib.rs @@ -25,7 +25,7 @@ use turbopack_core::{ context::AssetContext, ident::AssetIdent, module::Module, - output::OutputAsset, + output::{OutputAsset, OutputAssets}, reference::{AssetReferences, SingleAssetReference}, source::Source, }; @@ -228,14 +228,8 @@ struct StaticCssEmbed { #[turbo_tasks::value_impl] impl CssEmbed for StaticCssEmbed { #[turbo_tasks::function] - async fn references(&self) -> Result> { - Ok(Vc::cell(vec![Vc::upcast(SingleAssetReference::new( - Vc::upcast(self.static_asset), - Vc::cell(format!( - "static(url) {}", - self.static_asset.ident().path().await? - )), - ))])) + async fn references(&self) -> Result> { + Ok(Vc::cell(vec![Vc::upcast(self.static_asset)])) } #[turbo_tasks::function] diff --git a/crates/turbopack-tests/tests/snapshot.rs b/crates/turbopack-tests/tests/snapshot.rs index f0b8834c8cef4..29a14698e6d65 100644 --- a/crates/turbopack-tests/tests/snapshot.rs +++ b/crates/turbopack-tests/tests/snapshot.rs @@ -39,7 +39,6 @@ use turbopack_core::{ issue::{Issue, IssueContextExt}, module::Module, output::OutputAsset, - reference::all_referenced_output_assets, reference_type::{EntryReferenceSubType, ReferenceType}, source::Source, }; @@ -409,7 +408,8 @@ async fn walk_asset( } queue.extend( - all_referenced_output_assets(asset) + asset + .references() .await? .iter() .copied() diff --git a/crates/turbopack/src/graph/mod.rs b/crates/turbopack/src/graph/mod.rs index e8e24dcda948f..2e2d37535db0d 100644 --- a/crates/turbopack/src/graph/mod.rs +++ b/crates/turbopack/src/graph/mod.rs @@ -2,7 +2,7 @@ use std::collections::HashSet; use anyhow::Result; use turbo_tasks::Vc; -use turbopack_core::{output::OutputAsset, reference::all_referenced_output_assets}; +use turbopack_core::output::OutputAsset; #[turbo_tasks::value(shared)] pub enum AggregatedGraph { @@ -48,7 +48,7 @@ impl AggregatedGraph { Ok(match *self.await? { AggregatedGraph::Leaf(asset) => { let mut refs = HashSet::new(); - for reference in all_referenced_output_assets(asset).await?.iter() { + for reference in asset.references().await?.iter() { let reference = reference.resolve().await?; if asset != reference { refs.insert(AggregatedGraph::leaf(reference)); @@ -74,9 +74,7 @@ impl AggregatedGraph { #[turbo_tasks::function] async fn cost(self: Vc) -> Result> { Ok(match *self.await? { - AggregatedGraph::Leaf(asset) => { - AggregationCost(all_referenced_output_assets(asset).await?.len()).into() - } + AggregatedGraph::Leaf(asset) => AggregationCost(asset.references().await?.len()).into(), AggregatedGraph::Node { ref references, .. } => { AggregationCost(references.len()).into() } diff --git a/crates/turbopack/src/lib.rs b/crates/turbopack/src/lib.rs index 2a8122104863f..b203205d77809 100644 --- a/crates/turbopack/src/lib.rs +++ b/crates/turbopack/src/lib.rs @@ -43,7 +43,6 @@ use turbopack_core::{ module::Module, output::OutputAsset, raw_module::RawModule, - reference::all_referenced_output_assets, reference_type::{EcmaScriptModulesReferenceSubType, InnerAssets, ReferenceType}, resolve::{ options::ResolveOptions, origin::PlainResolveOrigin, parse::Request, resolve, ModulePart, @@ -565,7 +564,7 @@ async fn compute_back_references(aggregated: Vc) -> Result { let mut referenced_by = HashMap::new(); - for reference in all_referenced_output_assets(asset).await?.iter() { + for reference in asset.references().await?.iter() { referenced_by.insert(*reference, [asset].into_iter().collect()); } ReferencesList { referenced_by }.into() diff --git a/crates/turbopack/src/rebase/mod.rs b/crates/turbopack/src/rebase/mod.rs index a5864ad42241d..de60990a40f13 100644 --- a/crates/turbopack/src/rebase/mod.rs +++ b/crates/turbopack/src/rebase/mod.rs @@ -1,15 +1,14 @@ use std::hash::Hash; use anyhow::Result; -use turbo_tasks::{ValueToString, Vc}; +use turbo_tasks::Vc; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ asset::{Asset, AssetContent}, ident::AssetIdent, - module::{convert_asset_to_module, Module}, - output::OutputAsset, - reference::{AssetReference, AssetReferences}, - resolve::ResolveResult, + module::Module, + output::{OutputAsset, OutputAssets}, + reference::all_referenced_modules, }; /// Converts a [Module] graph into an [OutputAsset] graph by placing it into a @@ -50,13 +49,12 @@ impl OutputAsset for RebasedAsset { } #[turbo_tasks::function] - async fn references(&self) -> Result> { - let input_references = self.source.references().await?; + async fn references(&self) -> Result> { let mut references = Vec::new(); - for reference in input_references.iter() { + for &module in all_referenced_modules(self.source).await?.iter() { references.push(Vc::upcast( - RebasedAssetReference { - reference: *reference, + RebasedAsset { + source: module, input_dir: self.input_dir, output_dir: self.output_dir, } @@ -74,51 +72,3 @@ impl Asset for RebasedAsset { self.source.content() } } - -#[turbo_tasks::value(shared)] -struct RebasedAssetReference { - reference: Vc>, - input_dir: Vc, - output_dir: Vc, -} - -#[turbo_tasks::value_impl] -impl AssetReference for RebasedAssetReference { - #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { - let result = self.reference.resolve_reference().await?; - Ok(result - .map( - |asset| { - let module = convert_asset_to_module(asset); - let asset = - Vc::upcast(RebasedAsset::new(module, self.input_dir, self.output_dir)); - async move { Ok(asset) } - }, - |reference| { - let reference: Vc> = Vc::upcast( - RebasedAssetReference { - reference, - input_dir: self.input_dir, - output_dir: self.output_dir, - } - .cell(), - ); - async move { Ok(reference) } - }, - ) - .await? - .into()) - } -} - -#[turbo_tasks::value_impl] -impl ValueToString for RebasedAssetReference { - #[turbo_tasks::function] - async fn to_string(&self) -> Result> { - Ok(Vc::cell(format!( - "rebased {}", - self.reference.to_string().await? - ))) - } -} From 8f055421c61cb90fdc730e07aa5c6ecceba7039c Mon Sep 17 00:00:00 2001 From: Tobias Koppers Date: Tue, 18 Jul 2023 14:09:41 +0000 Subject: [PATCH 2/3] clippy --- crates/turbopack-build/src/ecmascript/node/chunk.rs | 5 ++--- crates/turbopack-dev/src/ecmascript/chunk.rs | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/crates/turbopack-build/src/ecmascript/node/chunk.rs b/crates/turbopack-build/src/ecmascript/node/chunk.rs index 8ee2644c50c38..5bbad311de694 100644 --- a/crates/turbopack-build/src/ecmascript/node/chunk.rs +++ b/crates/turbopack-build/src/ecmascript/node/chunk.rs @@ -76,9 +76,8 @@ impl OutputAsset for EcmascriptBuildNodeChunk { .chunking_context .reference_chunk_source_maps(Vc::upcast(self)) .await?; - let mut references = Vec::with_capacity( - chunk_references.len() + include_source_map.then_some(1).unwrap_or(0), - ); + let mut references = + Vec::with_capacity(chunk_references.len() + if include_source_map { 1 } else { 0 }); for reference in &*chunk_references { references.push(*reference); diff --git a/crates/turbopack-dev/src/ecmascript/chunk.rs b/crates/turbopack-dev/src/ecmascript/chunk.rs index 932a04bbe2d48..f152e7490518b 100644 --- a/crates/turbopack-dev/src/ecmascript/chunk.rs +++ b/crates/turbopack-dev/src/ecmascript/chunk.rs @@ -88,9 +88,8 @@ impl OutputAsset for EcmascriptDevChunk { .chunking_context .reference_chunk_source_maps(Vc::upcast(self)) .await?; - let mut references = Vec::with_capacity( - chunk_references.len() + include_source_map.then_some(1).unwrap_or(0), - ); + let mut references = + Vec::with_capacity(chunk_references.len() + if include_source_map { 1 } else { 0 }); references.extend(chunk_references.iter().copied()); From fc2fde63931a4ed74776f485182102b7fb1a3496 Mon Sep 17 00:00:00 2001 From: Tobias Koppers Date: Tue, 18 Jul 2023 19:10:05 +0000 Subject: [PATCH 3/3] fix infinite recursion --- crates/turbopack/src/rebase/mod.rs | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/crates/turbopack/src/rebase/mod.rs b/crates/turbopack/src/rebase/mod.rs index de60990a40f13..bb74be2b474c7 100644 --- a/crates/turbopack/src/rebase/mod.rs +++ b/crates/turbopack/src/rebase/mod.rs @@ -52,14 +52,11 @@ impl OutputAsset for RebasedAsset { async fn references(&self) -> Result> { let mut references = Vec::new(); for &module in all_referenced_modules(self.source).await?.iter() { - references.push(Vc::upcast( - RebasedAsset { - source: module, - input_dir: self.input_dir, - output_dir: self.output_dir, - } - .cell(), - )); + references.push(Vc::upcast(RebasedAsset::new( + module, + self.input_dir, + self.output_dir, + ))); } Ok(Vc::cell(references)) }