From c4d1d3183af9382b6ff725b002354a9b85d8f7d0 Mon Sep 17 00:00:00 2001 From: Tobias Koppers Date: Fri, 21 Jul 2023 12:04:24 +0200 Subject: [PATCH] Refactoring module references (#5572) ### Description Split `AssetReference` `ResolveResult` into Module and Source variants simplify ResolveResult get rid of some temporary type fixup methods graph references are now typed either Source, Module or OutputAsset instead of only Asset in general next.js PR: https://github.com/vercel/next.js/pull/52930 --- .../turbopack-cli-utils/src/runtime_entry.rs | 15 +- crates/turbopack-cli/src/build/mod.rs | 7 +- .../turbopack-cli/src/dev/web_entry_source.rs | 2 +- crates/turbopack-core/src/asset.rs | 32 - .../src/chunk/availability_info.rs | 10 +- ...ailable_assets.rs => available_modules.rs} | 18 +- crates/turbopack-core/src/chunk/mod.rs | 146 ++-- .../src/chunk/passthrough_asset.rs | 4 +- crates/turbopack-core/src/context.rs | 6 +- crates/turbopack-core/src/file_source.rs | 4 +- crates/turbopack-core/src/introspect/asset.rs | 178 ----- crates/turbopack-core/src/introspect/mod.rs | 5 +- .../turbopack-core/src/introspect/module.rs | 49 ++ .../src/introspect/output_asset.rs | 49 ++ .../turbopack-core/src/introspect/source.rs | 41 ++ crates/turbopack-core/src/introspect/utils.rs | 118 ++++ crates/turbopack-core/src/module.rs | 30 +- crates/turbopack-core/src/output.rs | 11 - crates/turbopack-core/src/reference/mod.rs | 144 ++-- .../src/reference/source_map.rs | 15 +- crates/turbopack-core/src/resolve/mod.rs | 623 ++++++++++++++---- crates/turbopack-core/src/resolve/options.rs | 17 +- crates/turbopack-core/src/resolve/origin.rs | 10 +- crates/turbopack-core/src/source.rs | 32 +- crates/turbopack-core/src/virtual_output.rs | 2 +- crates/turbopack-core/src/virtual_source.rs | 2 +- crates/turbopack-css/src/asset.rs | 48 +- crates/turbopack-css/src/chunk/mod.rs | 35 +- crates/turbopack-css/src/code_gen.rs | 2 +- crates/turbopack-css/src/embed.rs | 2 +- crates/turbopack-css/src/global_asset.rs | 8 +- crates/turbopack-css/src/module_asset.rs | 10 +- .../turbopack-css/src/references/compose.rs | 8 +- crates/turbopack-css/src/references/import.rs | 8 +- .../turbopack-css/src/references/internal.rs | 10 +- crates/turbopack-css/src/references/mod.rs | 20 +- crates/turbopack-css/src/references/url.rs | 26 +- crates/turbopack-dev-server/src/html.rs | 4 +- .../src/source/asset_graph.rs | 13 +- .../src/source/static_assets.rs | 4 +- .../turbopack-dev/src/ecmascript/runtime.rs | 1 - crates/turbopack-dev/src/react_refresh.rs | 3 +- .../turbopack-ecmascript/src/chunk/content.rs | 14 +- .../src/chunk/esm_scope.rs | 4 +- crates/turbopack-ecmascript/src/chunk/item.rs | 8 +- crates/turbopack-ecmascript/src/chunk/mod.rs | 21 +- .../src/chunk_group_files_asset.rs | 27 +- crates/turbopack-ecmascript/src/code_gen.rs | 2 +- crates/turbopack-ecmascript/src/lib.rs | 8 +- .../src/manifest/chunk_asset.rs | 8 +- .../src/manifest/chunk_item.rs | 6 +- .../src/manifest/loader_item.rs | 14 +- .../src/references/amd.rs | 8 +- .../src/references/cjs.rs | 16 +- .../src/references/esm/base.rs | 18 +- .../src/references/esm/dynamic.rs | 8 +- .../src/references/esm/module_id.rs | 8 +- .../src/references/esm/url.rs | 8 +- .../src/references/mod.rs | 48 +- .../src/references/node.rs | 39 +- .../src/references/pattern_mapping.rs | 31 +- .../src/references/raw.rs | 10 +- .../src/references/require_context.rs | 28 +- .../src/references/typescript.rs | 24 +- .../turbopack-ecmascript/src/resolve/mod.rs | 20 +- .../src/resolve/node_native_binding.rs | 100 +-- .../src/tree_shake/asset.rs | 6 +- .../src/tree_shake/chunk_item.rs | 4 +- .../src/typescript/mod.rs | 25 +- .../src/typescript/resolve.rs | 28 +- .../turbopack-ecmascript/src/webpack/mod.rs | 32 +- .../src/webpack/references.rs | 12 +- crates/turbopack-json/src/lib.rs | 4 +- crates/turbopack-mdx/src/lib.rs | 6 +- .../src/render/node_api_source.rs | 9 +- .../src/render/rendered_source.rs | 11 +- crates/turbopack-static/src/lib.rs | 6 +- crates/turbopack/src/lib.rs | 20 +- 78 files changed, 1398 insertions(+), 1015 deletions(-) rename crates/turbopack-core/src/chunk/{available_assets.rs => available_modules.rs} (84%) delete mode 100644 crates/turbopack-core/src/introspect/asset.rs create mode 100644 crates/turbopack-core/src/introspect/module.rs create mode 100644 crates/turbopack-core/src/introspect/output_asset.rs create mode 100644 crates/turbopack-core/src/introspect/source.rs create mode 100644 crates/turbopack-core/src/introspect/utils.rs diff --git a/crates/turbopack-cli-utils/src/runtime_entry.rs b/crates/turbopack-cli-utils/src/runtime_entry.rs index e68ce76640631..648e8a454e7f7 100644 --- a/crates/turbopack-cli-utils/src/runtime_entry.rs +++ b/crates/turbopack-cli-utils/src/runtime_entry.rs @@ -5,7 +5,7 @@ use turbopack_core::{ chunk::{EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets}, context::AssetContext, issue::{IssueSeverity, OptionIssueSource}, - module::{convert_asset_to_module, Module}, + module::Module, resolve::{origin::PlainResolveOrigin, parse::Request}, source::Source, }; @@ -33,26 +33,25 @@ impl RuntimeEntry { RuntimeEntry::Request(r, path) => (r, path), }; - let assets = cjs_resolve( + let modules = cjs_resolve( Vc::upcast(PlainResolveOrigin::new(context, path)), request, OptionIssueSource::none(), IssueSeverity::Error.cell(), ) - .primary_assets() + .primary_modules() .await?; - let mut runtime_entries = Vec::with_capacity(assets.len()); - for &asset in &assets { + let mut runtime_entries = Vec::with_capacity(modules.len()); + for &module in &modules { if let Some(entry) = - Vc::try_resolve_sidecast::>(asset).await? + Vc::try_resolve_sidecast::>(module).await? { runtime_entries.push(entry); } else { - let asset = convert_asset_to_module(asset); bail!( "runtime reference resolved to an asset ({}) that cannot be evaluated", - asset.ident().to_string().await? + module.ident().to_string().await? ); } } diff --git a/crates/turbopack-cli/src/build/mod.rs b/crates/turbopack-cli/src/build/mod.rs index 30b524569533d..6f02bd496fc66 100644 --- a/crates/turbopack-cli/src/build/mod.rs +++ b/crates/turbopack-cli/src/build/mod.rs @@ -211,18 +211,17 @@ async fn build_internal( .map(|request_vc| async move { let ty = Value::new(ReferenceType::Entry(EntryReferenceSubType::Undefined)); let request = request_vc.await?; - Ok(*origin + origin .resolve_asset(request_vc, origin.resolve_options(ty.clone()), ty) - .primary_assets() + .first_module() .await? - .first() .with_context(|| { format!( "Unable to resolve entry {} from directory {}.", request.request().unwrap(), project_dir ) - })?) + }) }) .try_join() .await?; diff --git a/crates/turbopack-cli/src/dev/web_entry_source.rs b/crates/turbopack-cli/src/dev/web_entry_source.rs index b0d5ebc68cdb9..2c36238a9ea8a 100644 --- a/crates/turbopack-cli/src/dev/web_entry_source.rs +++ b/crates/turbopack-cli/src/dev/web_entry_source.rs @@ -105,7 +105,7 @@ pub async fn create_web_entry_source( let ty = Value::new(ReferenceType::Entry(EntryReferenceSubType::Web)); Ok(origin .resolve_asset(request, origin.resolve_options(ty.clone()), ty) - .primary_assets() + .primary_modules() .await? .first() .copied()) diff --git a/crates/turbopack-core/src/asset.rs b/crates/turbopack-core/src/asset.rs index cd1511f1af6bb..9d1873b42afd6 100644 --- a/crates/turbopack-core/src/asset.rs +++ b/crates/turbopack-core/src/asset.rs @@ -1,5 +1,4 @@ use anyhow::Result; -use indexmap::IndexSet; use turbo_tasks::{Completion, Vc}; use turbo_tasks_fs::{ FileContent, FileJsonContent, FileLinesContent, FileSystemPath, LinkContent, LinkType, @@ -7,33 +6,6 @@ use turbo_tasks_fs::{ use crate::version::{VersionedAssetContent, VersionedContent}; -/// A list of [Asset]s -#[turbo_tasks::value(transparent)] -#[derive(Hash)] -pub struct Assets(Vec>>); - -/// A set of [Asset]s -#[turbo_tasks::value(transparent)] -pub struct AssetsSet(IndexSet>>); - -#[turbo_tasks::value_impl] -impl Assets { - /// Creates an empty list of [Asset]s - #[turbo_tasks::function] - pub fn empty() -> Vc { - Vc::cell(Vec::new()) - } -} - -#[turbo_tasks::value_impl] -impl AssetsSet { - /// Creates an empty set of [Asset]s - #[turbo_tasks::function] - pub fn empty() -> Vc { - Vc::cell(IndexSet::new()) - } -} - /// An asset. It also forms a graph when following [Asset::references]. #[turbo_tasks::value_trait] pub trait Asset { @@ -46,10 +18,6 @@ pub trait Asset { } } -/// An optional [Asset] -#[turbo_tasks::value(shared, transparent)] -pub struct AssetOption(Option>>); - #[turbo_tasks::value(shared)] #[derive(Clone)] pub enum AssetContent { diff --git a/crates/turbopack-core/src/chunk/availability_info.rs b/crates/turbopack-core/src/chunk/availability_info.rs index 93dd59dbac407..a1cb3c01f100e 100644 --- a/crates/turbopack-core/src/chunk/availability_info.rs +++ b/crates/turbopack-core/src/chunk/availability_info.rs @@ -1,6 +1,6 @@ use turbo_tasks::Vc; -use super::available_assets::AvailableAssets; +use super::available_modules::AvailableAssets; use crate::module::Module; #[turbo_tasks::value(serialization = "auto_for_input")] @@ -11,7 +11,7 @@ pub enum AvailabilityInfo { current_availability_root: Vc>, }, Inner { - available_assets: Vc, + available_modules: Vc, current_availability_root: Vc>, }, } @@ -30,13 +30,13 @@ impl AvailabilityInfo { } } - pub fn available_assets(&self) -> Option> { + pub fn available_modules(&self) -> Option> { match self { Self::Untracked => None, Self::Root { .. } => None, Self::Inner { - available_assets, .. - } => Some(*available_assets), + available_modules, .. + } => Some(*available_modules), } } } diff --git a/crates/turbopack-core/src/chunk/available_assets.rs b/crates/turbopack-core/src/chunk/available_modules.rs similarity index 84% rename from crates/turbopack-core/src/chunk/available_assets.rs rename to crates/turbopack-core/src/chunk/available_modules.rs index 058703f7458cb..f203f796fc080 100644 --- a/crates/turbopack-core/src/chunk/available_assets.rs +++ b/crates/turbopack-core/src/chunk/available_modules.rs @@ -11,7 +11,7 @@ use turbo_tasks_hash::Xxh3Hash64Hasher; use super::{ChunkableModuleReference, ChunkingType}; use crate::{ module::{Module, ModulesSet}, - reference::AssetReference, + reference::ModuleReference, }; /// Allows to gather information about which assets are already available. @@ -75,7 +75,7 @@ impl AvailableAssets { } } for root in this.roots.iter() { - if chunkable_assets_set(*root).await?.contains(&asset) { + if chunkable_modules_set(*root).await?.contains(&asset) { return Ok(Vc::cell(true)); } } @@ -84,7 +84,7 @@ impl AvailableAssets { } #[turbo_tasks::function] -pub async fn chunkable_assets_set(root: Vc>) -> Result> { +pub async fn chunkable_modules_set(root: Vc>) -> Result> { let assets = AdjacencyMap::new() .skip_duplicates() .visit(once(root), |&asset: &Vc>| async move { @@ -108,17 +108,9 @@ pub async fn chunkable_assets_set(root: Vc>) -> Result>(asset).await?) - }) - .try_join() - .await? - .into_iter() - .flatten() - .collect()); + .clone_value()); } } Ok(Vec::new()) diff --git a/crates/turbopack-core/src/chunk/mod.rs b/crates/turbopack-core/src/chunk/mod.rs index b96f746279460..8c92fc22f13d1 100644 --- a/crates/turbopack-core/src/chunk/mod.rs +++ b/crates/turbopack-core/src/chunk/mod.rs @@ -1,5 +1,5 @@ pub mod availability_info; -pub mod available_assets; +pub mod available_modules; pub(crate) mod chunking_context; pub(crate) mod containment_tree; pub(crate) mod data; @@ -32,15 +32,15 @@ pub use self::{ chunking_context::ChunkingContext, data::{ChunkData, ChunkDataOption, ChunksData}, evaluate::{EvaluatableAsset, EvaluatableAssetExt, EvaluatableAssets}, - passthrough_asset::PassthroughAsset, + passthrough_asset::PassthroughModule, }; use crate::{ asset::Asset, ident::AssetIdent, module::{Module, Modules}, output::OutputAssets, - reference::{AssetReference, AssetReferences}, - resolve::{PrimaryResolveResult, ResolveResult}, + reference::{ModuleReference, ModuleReferences}, + resolve::ModuleResolveResult, }; /// A module id, which can be a number or string @@ -82,7 +82,7 @@ impl ModuleId { #[turbo_tasks::value(transparent, shared)] pub struct ModuleIds(Vec>); -/// An [Asset] that can be converted into a [Chunk]. +/// A [Module] that can be converted into a [Chunk]. #[turbo_tasks::value_trait] pub trait ChunkableModule: Module + Asset { fn as_chunk( @@ -133,8 +133,7 @@ pub trait Chunk: Asset { Chunks::empty() } - /// Other things (most likely [Asset]s) referenced from this [Chunk]. - // TODO refactor this to ensure that only [OutputAsset]s can be referenced + /// Other [OutputAsset]s referenced from this [Chunk]. fn references(self: Vc) -> Vc { OutputAssets::empty() } @@ -185,14 +184,14 @@ pub enum ChunkingType { #[turbo_tasks::value(transparent)] pub struct ChunkingTypeOption(Option); -/// An [AssetReference] implementing this trait and returning true for +/// A [ModuleReference] implementing this trait and returning true for /// [ChunkableModuleReference::is_chunkable] are considered as potentially -/// chunkable references. When all [Asset]s of such a reference implement +/// chunkable references. When all [Module]s of such a reference implement /// [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 ChunkableModuleReference: AssetReference + ValueToString { +pub trait ChunkableModuleReference: ModuleReference + ValueToString { fn chunking_type(self: Vc) -> Vc { Vc::cell(Some(ChunkingType::default())) } @@ -226,16 +225,11 @@ impl ChunkGroupReference { } #[turbo_tasks::value_impl] -impl AssetReference for ChunkGroupReference { +impl ModuleReference for ChunkGroupReference { #[turbo_tasks::function] - async fn resolve_reference(self: Vc) -> Result> { - let set = self - .chunks() - .await? - .iter() - .map(|&c| Vc::upcast(c)) - .collect(); - Ok(ResolveResult::assets(set).into()) + async fn resolve_reference(self: Vc) -> Result> { + let set = self.chunks().await?.clone_value(); + Ok(ModuleResolveResult::output_assets(set).cell()) } } @@ -253,7 +247,7 @@ impl ValueToString for ChunkGroupReference { pub struct ChunkContentResult { pub chunk_items: Vec, pub chunks: Vec>>, - pub external_asset_references: Vec>>, + pub external_module_references: Vec>>, pub availability_info: AvailabilityInfo, } @@ -301,14 +295,14 @@ where enum ChunkContentGraphNode { // An asset not placed in the current chunk, but whose references we will // follow to find more graph nodes. - PassthroughAsset { asset: Vc> }, + PassthroughModule { asset: Vc> }, // Chunk items that are placed into the current chunk ChunkItem { item: I, ident: ReadRef }, // Asset that is already available and doesn't need to be included AvailableAsset(Vc>), // Chunks that are loaded in parallel to the current chunk Chunk(Vc>), - ExternalAssetReference(Vc>), + ExternalModuleReference(Vc>), } #[derive(Clone, Copy)] @@ -321,7 +315,7 @@ struct ChunkContentContext { async fn reference_to_graph_nodes( context: ChunkContentContext, - reference: Vc>, + reference: Vc>, ) -> Result< Vec<( Option<(Vc>, ChunkingType)>, @@ -331,99 +325,90 @@ async fn reference_to_graph_nodes( where I: FromChunkableModule, { - let Some(chunkable_asset_reference) = + let Some(chunkable_module_reference) = Vc::try_resolve_downcast::>(reference).await? else { return Ok(vec![( None, - ChunkContentGraphNode::ExternalAssetReference(reference), + ChunkContentGraphNode::ExternalModuleReference(reference), )]); }; - let Some(chunking_type) = *chunkable_asset_reference.chunking_type().await? else { + let Some(chunking_type) = *chunkable_module_reference.chunking_type().await? else { return Ok(vec![( None, - ChunkContentGraphNode::ExternalAssetReference(reference), + ChunkContentGraphNode::ExternalModuleReference(reference), )]); }; - let result = reference.resolve_reference().await?; - - let assets = result.primary.iter().filter_map({ - |result| { - if let PrimaryResolveResult::Asset(asset) = *result { - return Some(asset); - } - None - } - }); + let modules = reference.resolve_reference().primary_modules().await?; let mut graph_nodes = vec![]; - for asset in assets { - let asset = asset.resolve().await?; - let Some(asset) = Vc::try_resolve_downcast::>(asset).await? else { - continue; - }; - if let Some(available_assets) = context.availability_info.available_assets() { - if *available_assets.includes(asset).await? { + for &module in &modules { + let module = module.resolve().await?; + if let Some(available_modules) = context.availability_info.available_modules() { + if *available_modules.includes(module).await? { graph_nodes.push(( - Some((asset, chunking_type)), - ChunkContentGraphNode::AvailableAsset(asset), + Some((module, chunking_type)), + ChunkContentGraphNode::AvailableAsset(module), )); continue; } } - if Vc::try_resolve_sidecast::>(asset) + if Vc::try_resolve_sidecast::>(module) .await? .is_some() { - graph_nodes.push((None, ChunkContentGraphNode::PassthroughAsset { asset })); + graph_nodes.push(( + None, + ChunkContentGraphNode::PassthroughModule { asset: module }, + )); continue; } - let chunkable_asset = - match Vc::try_resolve_sidecast::>(asset).await? { - Some(chunkable_asset) => chunkable_asset, + let chunkable_module = + match Vc::try_resolve_sidecast::>(module).await? { + Some(chunkable_module) => chunkable_module, _ => { return Ok(vec![( None, - ChunkContentGraphNode::ExternalAssetReference(reference), + ChunkContentGraphNode::ExternalModuleReference(reference), )]); } }; match chunking_type { ChunkingType::Placed => { - if let Some(chunk_item) = I::from_asset(context.chunking_context, asset).await? { + if let Some(chunk_item) = I::from_asset(context.chunking_context, module).await? { graph_nodes.push(( - Some((asset, chunking_type)), + Some((module, chunking_type)), ChunkContentGraphNode::ChunkItem { item: chunk_item, - ident: asset.ident().to_string().await?, + ident: module.ident().to_string().await?, }, )); } else { return Err(anyhow!( - "Asset {} was requested to be placed into the same chunk, but this \ + "Module {} was requested to be placed into the same chunk, but this \ wasn't possible", - asset.ident().to_string().await? + module.ident().to_string().await? )); } } ChunkingType::Parallel => { let chunk = - chunkable_asset.as_chunk(context.chunking_context, context.availability_info); + chunkable_module.as_chunk(context.chunking_context, context.availability_info); graph_nodes.push(( - Some((asset, chunking_type)), + Some((module, chunking_type)), ChunkContentGraphNode::Chunk(chunk), )); } ChunkingType::IsolatedParallel => { - let chunk = chunkable_asset.as_root_chunk(context.chunking_context); + let chunk = chunkable_module.as_root_chunk(context.chunking_context); graph_nodes.push(( - Some((asset, chunking_type)), + Some((module, chunking_type)), ChunkContentGraphNode::Chunk(chunk), )); } @@ -432,17 +417,18 @@ where if !context.split && *context .chunking_context - .can_be_in_same_chunk(context.entry, asset) + .can_be_in_same_chunk(context.entry, module) .await? { // chunk item, chunk or other asset? - if let Some(chunk_item) = I::from_asset(context.chunking_context, asset).await? + if let Some(chunk_item) = + I::from_asset(context.chunking_context, module).await? { graph_nodes.push(( - Some((asset, chunking_type)), + Some((module, chunking_type)), ChunkContentGraphNode::ChunkItem { item: chunk_item, - ident: asset.ident().to_string().await?, + ident: module.ident().to_string().await?, }, )); continue; @@ -450,31 +436,31 @@ where } let chunk = - chunkable_asset.as_chunk(context.chunking_context, context.availability_info); + chunkable_module.as_chunk(context.chunking_context, context.availability_info); graph_nodes.push(( - Some((asset, chunking_type)), + Some((module, chunking_type)), ChunkContentGraphNode::Chunk(chunk), )); } ChunkingType::Async => { if let Some(manifest_loader_item) = I::from_async_asset( context.chunking_context, - chunkable_asset, + chunkable_module, context.availability_info, ) .await? { graph_nodes.push(( - Some((asset, chunking_type)), + Some((module, chunking_type)), ChunkContentGraphNode::ChunkItem { item: manifest_loader_item, - ident: asset.ident().to_string().await?, + ident: module.ident().to_string().await?, }, )); } else { return Ok(vec![( None, - ChunkContentGraphNode::ExternalAssetReference(reference), + ChunkContentGraphNode::ExternalModuleReference(reference), )]); } } @@ -553,7 +539,7 @@ where async move { let references = match node { - ChunkContentGraphNode::PassthroughAsset { asset } => asset.references(), + ChunkContentGraphNode::PassthroughModule { asset } => asset.references(), ChunkContentGraphNode::ChunkItem { item, .. } => item.references(), _ => { return Ok(vec![].into_iter().flatten()); @@ -635,20 +621,20 @@ where let mut chunk_items = Vec::new(); let mut chunks = Vec::new(); - let mut external_asset_references = Vec::new(); + let mut external_module_references = Vec::new(); for graph_node in graph_nodes { match graph_node { ChunkContentGraphNode::AvailableAsset(_) - | ChunkContentGraphNode::PassthroughAsset { .. } => {} + | ChunkContentGraphNode::PassthroughModule { .. } => {} ChunkContentGraphNode::ChunkItem { item, .. } => { chunk_items.push(item); } ChunkContentGraphNode::Chunk(chunk) => { chunks.push(chunk); } - ChunkContentGraphNode::ExternalAssetReference(reference) => { - external_asset_references.push(reference); + ChunkContentGraphNode::ExternalModuleReference(reference) => { + external_module_references.push(reference); } } } @@ -656,22 +642,22 @@ where Ok(Some(ChunkContentResult { chunk_items, chunks, - external_asset_references, + external_module_references, availability_info: availability_info.into_value(), })) } #[turbo_tasks::value_trait] pub trait ChunkItem { - /// The [AssetIdent] of the [Asset] that this [ChunkItem] was created from. + /// The [AssetIdent] of the [Module] that this [ChunkItem] was created from. /// For most chunk types this must uniquely identify the asset as it's the /// source of the module id used at runtime. fn asset_ident(self: Vc) -> Vc; /// A [ChunkItem] can describe different `references` than its original - /// [Asset]. + /// [Module]. /// TODO(alexkirsz) This should have a default impl that returns empty /// references. - fn references(self: Vc) -> Vc; + fn references(self: Vc) -> Vc; } #[turbo_tasks::value(transparent)] diff --git a/crates/turbopack-core/src/chunk/passthrough_asset.rs b/crates/turbopack-core/src/chunk/passthrough_asset.rs index ee42f7a2555ee..cb2fc0652e00e 100644 --- a/crates/turbopack-core/src/chunk/passthrough_asset.rs +++ b/crates/turbopack-core/src/chunk/passthrough_asset.rs @@ -1,6 +1,6 @@ use crate::{asset::Asset, module::Module}; -/// An [Asset] that should never be placed into a chunk, but whose references +/// A [Module] that should never be placed into a chunk, but whose references /// should still be followed. #[turbo_tasks::value_trait] -pub trait PassthroughAsset: Module + Asset {} +pub trait PassthroughModule: Module + Asset {} diff --git a/crates/turbopack-core/src/context.rs b/crates/turbopack-core/src/context.rs index ead6fb2271cee..c96036debec40 100644 --- a/crates/turbopack-core/src/context.rs +++ b/crates/turbopack-core/src/context.rs @@ -5,7 +5,7 @@ use crate::{ compile_time_info::CompileTimeInfo, module::Module, reference_type::ReferenceType, - resolve::{options::ResolveOptions, parse::Request, ResolveResult}, + resolve::{options::ResolveOptions, parse::Request, ModuleResolveResult, ResolveResult}, source::Source, }; @@ -26,7 +26,7 @@ pub trait AssetContext { request: Vc, resolve_options: Vc, reference_type: Value, - ) -> Vc; + ) -> Vc; fn process( self: Vc, asset: Vc>, @@ -36,6 +36,6 @@ pub trait AssetContext { self: Vc, result: Vc, reference_type: Value, - ) -> Vc; + ) -> Vc; fn with_transition(self: Vc, transition: String) -> Vc>; } diff --git a/crates/turbopack-core/src/file_source.rs b/crates/turbopack-core/src/file_source.rs index c46891e8d1250..4a14a29708d5c 100644 --- a/crates/turbopack-core/src/file_source.rs +++ b/crates/turbopack-core/src/file_source.rs @@ -8,8 +8,8 @@ use crate::{ source::Source, }; -/// The raw [Asset]. It represents raw content from a path without any -/// references to other [Asset]s. +/// The raw [Source]. It represents raw content from a path without any +/// references to other [Source]s. #[turbo_tasks::value] pub struct FileSource { pub path: Vc, diff --git a/crates/turbopack-core/src/introspect/asset.rs b/crates/turbopack-core/src/introspect/asset.rs deleted file mode 100644 index 16eb2f0f88a2e..0000000000000 --- a/crates/turbopack-core/src/introspect/asset.rs +++ /dev/null @@ -1,178 +0,0 @@ -use anyhow::{bail, Result}; -use indexmap::IndexSet; -use turbo_tasks::{ValueToString, Vc}; -use turbo_tasks_fs::FileContent; - -use super::{Introspectable, IntrospectableChildren}; -use crate::{ - asset::{Asset, AssetContent}, - chunk::{ChunkableModuleReference, ChunkingType}, - module::Module, - output::{OutputAsset, OutputAssets}, - reference::{AssetReference, AssetReferences}, - resolve::PrimaryResolveResult, - source::Source, -}; - -#[turbo_tasks::value] -pub struct IntrospectableAsset(Vc>); - -#[turbo_tasks::value_impl] -impl IntrospectableAsset { - #[turbo_tasks::function] - pub async fn new(asset: Vc>) -> Result>> { - Ok(Vc::try_resolve_sidecast::>(asset) - .await? - .unwrap_or_else(|| Vc::upcast(IntrospectableAsset(asset).cell()))) - } -} - -#[turbo_tasks::function] -fn asset_ty() -> Vc { - Vc::cell("asset".to_string()) -} - -#[turbo_tasks::function] -fn reference_ty() -> Vc { - Vc::cell("reference".to_string()) -} - -#[turbo_tasks::function] -fn placed_or_parallel_reference_ty() -> Vc { - Vc::cell("placed/parallel reference".to_string()) -} - -#[turbo_tasks::function] -fn placed_reference_ty() -> Vc { - Vc::cell("placed reference".to_string()) -} - -#[turbo_tasks::function] -fn parallel_reference_ty() -> Vc { - Vc::cell("parallel reference".to_string()) -} - -#[turbo_tasks::function] -fn isolated_parallel_reference_ty() -> Vc { - Vc::cell("isolated parallel reference".to_string()) -} - -#[turbo_tasks::function] -fn async_reference_ty() -> Vc { - Vc::cell("async reference".to_string()) -} - -#[turbo_tasks::value_impl] -impl Introspectable for IntrospectableAsset { - #[turbo_tasks::function] - fn ty(&self) -> Vc { - asset_ty() - } - - #[turbo_tasks::function] - async fn title(&self) -> Result> { - let asset = self.0.resolve().await?; - Ok( - if let Some(source) = Vc::try_resolve_downcast::>(asset).await? { - source.ident().to_string() - } else if let Some(module) = Vc::try_resolve_downcast::>(asset).await? { - module.ident().to_string() - } else if let Some(output_asset) = - Vc::try_resolve_downcast::>(asset).await? - { - output_asset.ident().to_string() - } else { - Vc::cell("unknown type".to_string()) - }, - ) - } - - #[turbo_tasks::function] - fn details(&self) -> Vc { - content_to_details(self.0.content()) - } - - #[turbo_tasks::function] - async fn children(&self) -> Result> { - let asset = self.0.resolve().await?; - Ok( - if Vc::try_resolve_downcast::>(asset) - .await? - .is_some() - { - Vc::cell(Default::default()) - } else if let Some(module) = Vc::try_resolve_downcast::>(asset).await? { - children_from_asset_references(module.references()) - } else if let Some(output_asset) = - Vc::try_resolve_downcast::>(asset).await? - { - children_from_output_assets(output_asset.references()) - } else { - bail!("unknown type") - }, - ) - } -} - -#[turbo_tasks::function] -pub async fn content_to_details(content: Vc) -> Result> { - Ok(match &*content.await? { - AssetContent::File(file_content) => match &*file_content.await? { - FileContent::Content(file) => { - let content = file.content(); - match content.to_str() { - Ok(str) => Vc::cell(str.into_owned()), - Err(_) => Vc::cell(format!("{} binary bytes", content.len())), - } - } - FileContent::NotFound => Vc::cell("not found".to_string()), - }, - AssetContent::Redirect { target, link_type } => { - Vc::cell(format!("redirect to {target} with type {link_type:?}")) - } - }) -} - -#[turbo_tasks::function] -pub async fn children_from_asset_references( - references: Vc, -) -> Result> { - let key = reference_ty(); - let mut children = IndexSet::new(); - let references = references.await?; - for reference in &*references { - let mut key = key; - if let Some(chunkable) = - Vc::try_resolve_downcast::>(*reference).await? - { - match &*chunkable.chunking_type().await? { - None => {} - Some(ChunkingType::Placed) => key = placed_reference_ty(), - Some(ChunkingType::Parallel) => key = parallel_reference_ty(), - Some(ChunkingType::IsolatedParallel) => key = isolated_parallel_reference_ty(), - Some(ChunkingType::PlacedOrParallel) => key = placed_or_parallel_reference_ty(), - Some(ChunkingType::Async) => key = async_reference_ty(), - } - } - - for result in reference.resolve_reference().await?.primary.iter() { - if let PrimaryResolveResult::Asset(asset) = result { - children.insert((key, IntrospectableAsset::new(*asset))); - } - } - } - 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/introspect/mod.rs b/crates/turbopack-core/src/introspect/mod.rs index 0275dde422b4d..a021cede41401 100644 --- a/crates/turbopack-core/src/introspect/mod.rs +++ b/crates/turbopack-core/src/introspect/mod.rs @@ -1,4 +1,7 @@ -pub mod asset; +pub mod module; +pub mod output_asset; +pub mod source; +pub mod utils; use indexmap::IndexSet; use turbo_tasks::Vc; diff --git a/crates/turbopack-core/src/introspect/module.rs b/crates/turbopack-core/src/introspect/module.rs new file mode 100644 index 0000000000000..8c40807e14468 --- /dev/null +++ b/crates/turbopack-core/src/introspect/module.rs @@ -0,0 +1,49 @@ +use anyhow::Result; +use turbo_tasks::{ValueToString, Vc}; + +use super::{ + utils::{children_from_module_references, content_to_details}, + Introspectable, IntrospectableChildren, +}; +use crate::{asset::Asset, module::Module}; + +#[turbo_tasks::value] +pub struct IntrospectableModule(Vc>); + +#[turbo_tasks::value_impl] +impl IntrospectableModule { + #[turbo_tasks::function] + pub async fn new(asset: Vc>) -> Result>> { + Ok(Vc::try_resolve_sidecast::>(asset) + .await? + .unwrap_or_else(|| Vc::upcast(IntrospectableModule(asset).cell()))) + } +} + +#[turbo_tasks::function] +fn ty() -> Vc { + Vc::cell("asset".to_string()) +} + +#[turbo_tasks::value_impl] +impl Introspectable for IntrospectableModule { + #[turbo_tasks::function] + fn ty(&self) -> Vc { + ty() + } + + #[turbo_tasks::function] + fn title(&self) -> Vc { + self.0.ident().to_string() + } + + #[turbo_tasks::function] + fn details(&self) -> Vc { + content_to_details(self.0.content()) + } + + #[turbo_tasks::function] + fn children(&self) -> Vc { + children_from_module_references(self.0.references()) + } +} diff --git a/crates/turbopack-core/src/introspect/output_asset.rs b/crates/turbopack-core/src/introspect/output_asset.rs new file mode 100644 index 0000000000000..3fed6c1cee3b6 --- /dev/null +++ b/crates/turbopack-core/src/introspect/output_asset.rs @@ -0,0 +1,49 @@ +use anyhow::Result; +use turbo_tasks::{ValueToString, Vc}; + +use super::{ + utils::{children_from_output_assets, content_to_details}, + Introspectable, IntrospectableChildren, +}; +use crate::{asset::Asset, output::OutputAsset}; + +#[turbo_tasks::value] +pub struct IntrospectableOutputAsset(Vc>); + +#[turbo_tasks::value_impl] +impl IntrospectableOutputAsset { + #[turbo_tasks::function] + pub async fn new(asset: Vc>) -> Result>> { + Ok(Vc::try_resolve_sidecast::>(asset) + .await? + .unwrap_or_else(|| Vc::upcast(IntrospectableOutputAsset(asset).cell()))) + } +} + +#[turbo_tasks::function] +fn ty() -> Vc { + Vc::cell("output asset".to_string()) +} + +#[turbo_tasks::value_impl] +impl Introspectable for IntrospectableOutputAsset { + #[turbo_tasks::function] + fn ty(&self) -> Vc { + ty() + } + + #[turbo_tasks::function] + fn title(&self) -> Vc { + self.0.ident().to_string() + } + + #[turbo_tasks::function] + fn details(&self) -> Vc { + content_to_details(self.0.content()) + } + + #[turbo_tasks::function] + fn children(&self) -> Vc { + children_from_output_assets(self.0.references()) + } +} diff --git a/crates/turbopack-core/src/introspect/source.rs b/crates/turbopack-core/src/introspect/source.rs new file mode 100644 index 0000000000000..ca28f44cbd17f --- /dev/null +++ b/crates/turbopack-core/src/introspect/source.rs @@ -0,0 +1,41 @@ +use anyhow::Result; +use turbo_tasks::{ValueToString, Vc}; + +use super::{utils::content_to_details, Introspectable}; +use crate::{asset::Asset, source::Source}; + +#[turbo_tasks::value] +pub struct IntrospectableSource(Vc>); + +#[turbo_tasks::value_impl] +impl IntrospectableSource { + #[turbo_tasks::function] + pub async fn new(asset: Vc>) -> Result>> { + Ok(Vc::try_resolve_sidecast::>(asset) + .await? + .unwrap_or_else(|| Vc::upcast(IntrospectableSource(asset).cell()))) + } +} + +#[turbo_tasks::function] +fn ty() -> Vc { + Vc::cell("source".to_string()) +} + +#[turbo_tasks::value_impl] +impl Introspectable for IntrospectableSource { + #[turbo_tasks::function] + fn ty(&self) -> Vc { + ty() + } + + #[turbo_tasks::function] + fn title(&self) -> Vc { + self.0.ident().to_string() + } + + #[turbo_tasks::function] + fn details(&self) -> Vc { + content_to_details(self.0.content()) + } +} diff --git a/crates/turbopack-core/src/introspect/utils.rs b/crates/turbopack-core/src/introspect/utils.rs new file mode 100644 index 0000000000000..543cc343044a2 --- /dev/null +++ b/crates/turbopack-core/src/introspect/utils.rs @@ -0,0 +1,118 @@ +use anyhow::Result; +use indexmap::IndexSet; +use turbo_tasks::Vc; +use turbo_tasks_fs::FileContent; + +use super::{ + module::IntrospectableModule, output_asset::IntrospectableOutputAsset, IntrospectableChildren, +}; +use crate::{ + asset::AssetContent, + chunk::{ChunkableModuleReference, ChunkingType}, + output::OutputAssets, + reference::{ModuleReference, ModuleReferences}, +}; + +#[turbo_tasks::function] +fn reference_ty() -> Vc { + Vc::cell("reference".to_string()) +} + +#[turbo_tasks::function] +fn placed_or_parallel_reference_ty() -> Vc { + Vc::cell("placed/parallel reference".to_string()) +} + +#[turbo_tasks::function] +fn placed_reference_ty() -> Vc { + Vc::cell("placed reference".to_string()) +} + +#[turbo_tasks::function] +fn parallel_reference_ty() -> Vc { + Vc::cell("parallel reference".to_string()) +} + +#[turbo_tasks::function] +fn isolated_parallel_reference_ty() -> Vc { + Vc::cell("isolated parallel reference".to_string()) +} + +#[turbo_tasks::function] +fn async_reference_ty() -> Vc { + Vc::cell("async reference".to_string()) +} + +#[turbo_tasks::function] +pub async fn content_to_details(content: Vc) -> Result> { + Ok(match &*content.await? { + AssetContent::File(file_content) => match &*file_content.await? { + FileContent::Content(file) => { + let content = file.content(); + match content.to_str() { + Ok(str) => Vc::cell(str.into_owned()), + Err(_) => Vc::cell(format!("{} binary bytes", content.len())), + } + } + FileContent::NotFound => Vc::cell("not found".to_string()), + }, + AssetContent::Redirect { target, link_type } => { + Vc::cell(format!("redirect to {target} with type {link_type:?}")) + } + }) +} + +#[turbo_tasks::function] +pub async fn children_from_module_references( + references: Vc, +) -> Result> { + let key = reference_ty(); + let mut children = IndexSet::new(); + let references = references.await?; + for reference in &*references { + let mut key = key; + if let Some(chunkable) = + Vc::try_resolve_downcast::>(*reference).await? + { + match &*chunkable.chunking_type().await? { + None => {} + Some(ChunkingType::Placed) => key = placed_reference_ty(), + Some(ChunkingType::Parallel) => key = parallel_reference_ty(), + Some(ChunkingType::IsolatedParallel) => key = isolated_parallel_reference_ty(), + Some(ChunkingType::PlacedOrParallel) => key = placed_or_parallel_reference_ty(), + Some(ChunkingType::Async) => key = async_reference_ty(), + } + } + + for &module in reference + .resolve_reference() + .primary_modules() + .await? + .iter() + { + children.insert((key, IntrospectableModule::new(module))); + } + for &output_asset in reference + .resolve_reference() + .primary_output_assets() + .await? + .iter() + { + children.insert((key, IntrospectableOutputAsset::new(output_asset))); + } + } + 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, IntrospectableOutputAsset::new(Vc::upcast(reference)))); + } + Ok(Vc::cell(children)) +} diff --git a/crates/turbopack-core/src/module.rs b/crates/turbopack-core/src/module.rs index c1ebaff7a29c8..8476476bf28e2 100644 --- a/crates/turbopack-core/src/module.rs +++ b/crates/turbopack-core/src/module.rs @@ -1,11 +1,7 @@ -use anyhow::{bail, Result}; use indexmap::IndexSet; use turbo_tasks::Vc; -use crate::{ - asset::Asset, ident::AssetIdent, raw_module::RawModule, reference::AssetReferences, - source::Source, -}; +use crate::{asset::Asset, ident::AssetIdent, reference::ModuleReferences}; /// A module. This usually represents parsed source code, which has references /// to other modules. @@ -15,10 +11,10 @@ pub trait Module: Asset { /// all properties of the [Module]. fn ident(&self) -> Vc; - /// Other things (most likely [Asset]s) referenced from this [Module]. - // TODO refactor this to ensure that only [Module]s can be referenced - fn references(self: Vc) -> Vc { - AssetReferences::empty() + /// Other [Module]s or [OutputAsset]s referenced from this [Module]. + // TODO refactor to avoid returning [OutputAsset]s here + fn references(self: Vc) -> Vc { + ModuleReferences::empty() } } @@ -48,20 +44,4 @@ impl ModulesSet { } } -/// This is a temporary function that should be removed once the [Module] -/// trait completely replaces the [Asset] trait. -/// It converts an [Asset] into a [Module], but either casting it or wrapping it -/// in a [RawModule]. -// TODO make this function unnecessary, it should never be a Source -#[turbo_tasks::function] -pub async fn convert_asset_to_module(asset: Vc>) -> Result>> { - if let Some(module) = Vc::try_resolve_downcast::>(asset).await? { - Ok(module) - } else if let Some(source) = Vc::try_resolve_downcast::>(asset).await? { - Ok(Vc::upcast(RawModule::new(source))) - } else { - bail!("Asset must be a Module or a Source") - } -} - // TODO All Vc::try_resolve_downcast::> calls should be removed diff --git a/crates/turbopack-core/src/output.rs b/crates/turbopack-core/src/output.rs index a467023dec284..d1a7bf1779549 100644 --- a/crates/turbopack-core/src/output.rs +++ b/crates/turbopack-core/src/output.rs @@ -1,4 +1,3 @@ -use anyhow::{Context, Result}; use indexmap::IndexSet; use turbo_tasks::Vc; @@ -34,15 +33,5 @@ impl OutputAssets { #[turbo_tasks::value(transparent)] pub struct OutputAssetsSet(IndexSet>>); -/// This is a temporary function that should be removed once the [OutputAsset] -/// trait completely replaces the [Asset] trait. -/// TODO make this function unnecessary -#[turbo_tasks::function] -pub async fn asset_to_output_asset(asset: Vc>) -> Result>> { - Vc::try_resolve_downcast::>(asset) - .await? - .context("Asset must be a OutputAsset") -} - // TODO All Vc::try_resolve_downcast::> calls should be // removed diff --git a/crates/turbopack-core/src/reference/mod.rs b/crates/turbopack-core/src/reference/mod.rs index fceede101958b..4c0e76560db53 100644 --- a/crates/turbopack-core/src/reference/mod.rs +++ b/crates/turbopack-core/src/reference/mod.rs @@ -7,66 +7,66 @@ use turbo_tasks::{ }; use crate::{ - asset::Asset, issue::IssueContextExt, - module::{convert_asset_to_module, Module, Modules}, + module::{Module, Modules}, output::{OutputAsset, OutputAssets}, - resolve::{PrimaryResolveResult, ResolveResult}, + resolve::ModuleResolveResult, }; pub mod source_map; pub use source_map::SourceMapReference; -/// 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. [ChunkableModuleReference] +/// A reference to one or multiple [Module]s, [OutputAsset]s or other special +/// things. There are a bunch of optional traits that can influence how these +/// references are handled. e. g. [ChunkableModuleReference] /// -/// [Asset]: crate::asset::Asset +/// [Module]: crate::module::Module +/// [OutputAsset]: crate::output::OutputAsset /// [ChunkableModuleReference]: crate::chunk::ChunkableModuleReference #[turbo_tasks::value_trait] -pub trait AssetReference: ValueToString { - fn resolve_reference(self: Vc) -> Vc; +pub trait ModuleReference: ValueToString { + fn resolve_reference(self: Vc) -> Vc; // TODO think about different types // fn kind(&self) -> Vc; } -/// Multiple [AssetReference]s +/// Multiple [ModuleReference]s #[turbo_tasks::value(transparent)] -pub struct AssetReferences(Vec>>); +pub struct ModuleReferences(Vec>>); #[turbo_tasks::value_impl] -impl AssetReferences { - /// An empty list of [AssetReference]s +impl ModuleReferences { + /// An empty list of [ModuleReference]s #[turbo_tasks::function] pub fn empty() -> Vc { Vc::cell(Vec::new()) } } -/// A reference that always resolves to a single asset. +/// A reference that always resolves to a single module. #[turbo_tasks::value] -pub struct SingleAssetReference { - asset: Vc>, +pub struct SingleModuleReference { + asset: Vc>, description: Vc, } -impl SingleAssetReference { +impl SingleModuleReference { /// Returns the asset that this reference resolves to. - pub fn asset_ref(&self) -> Vc> { + pub fn asset_ref(&self) -> Vc> { self.asset } } #[turbo_tasks::value_impl] -impl AssetReference for SingleAssetReference { +impl ModuleReference for SingleModuleReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(self.asset).cell() + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(self.asset).cell() } } #[turbo_tasks::value_impl] -impl ValueToString for SingleAssetReference { +impl ValueToString for SingleModuleReference { #[turbo_tasks::function] fn to_string(&self) -> Vc { self.description @@ -74,30 +74,76 @@ impl ValueToString for SingleAssetReference { } #[turbo_tasks::value_impl] -impl SingleAssetReference { - /// Create a new [Vc] that resolves to the given +impl SingleModuleReference { + /// Create a new [Vc] that resolves to the given /// asset. #[turbo_tasks::function] - pub fn new(asset: Vc>, description: Vc) -> Vc { - Self::cell(SingleAssetReference { asset, description }) + pub fn new(asset: Vc>, description: Vc) -> Vc { + Self::cell(SingleModuleReference { asset, description }) } /// The [Vc>] that this reference resolves to. #[turbo_tasks::function] - pub async fn asset(self: Vc) -> Result>> { + pub async fn asset(self: Vc) -> Result>> { Ok(self.await?.asset) } } -/// 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. +/// A reference that always resolves to a single module. +#[turbo_tasks::value] +pub struct SingleOutputAssetReference { + asset: Vc>, + description: Vc, +} + +impl SingleOutputAssetReference { + /// Returns the asset that this reference resolves to. + pub fn asset_ref(&self) -> Vc> { + self.asset + } +} + +#[turbo_tasks::value_impl] +impl ModuleReference for SingleOutputAssetReference { + #[turbo_tasks::function] + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::output_asset(self.asset).cell() + } +} + +#[turbo_tasks::value_impl] +impl ValueToString for SingleOutputAssetReference { + #[turbo_tasks::function] + fn to_string(&self) -> Vc { + self.description + } +} + +#[turbo_tasks::value_impl] +impl SingleOutputAssetReference { + /// Create a new [Vc] that resolves to the given + /// asset. + #[turbo_tasks::function] + pub fn new(asset: Vc>, description: Vc) -> Vc { + Self::cell(SingleOutputAssetReference { asset, description }) + } + + /// The [Vc>] that this reference resolves to. + #[turbo_tasks::function] + pub async fn asset(self: Vc) -> Result>> { + Ok(self.await?.asset) + } +} + +/// Aggregates all [Module]s referenced by an [Module]. [ModuleReference] +/// This does not include transitively references [Module]s, but it includes +/// primary and secondary [Module]s referenced. /// -/// [Asset]: crate::asset::Asset +/// [Module]: crate::module::Module #[turbo_tasks::function] pub async fn all_referenced_modules(module: Vc>) -> Result> { let references_set = module.references().await?; - let mut assets = Vec::new(); + let mut modules = Vec::new(); let mut queue = VecDeque::with_capacity(32); for reference in references_set.iter() { queue.push_back(reference.resolve_reference()); @@ -106,20 +152,11 @@ pub async fn all_referenced_modules(module: Vc>) -> Result>) -> Result>()) + Ok(reference + .resolve_reference() + .primary_modules() + .await? + .clone_value()) }) .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(modules)) } diff --git a/crates/turbopack-core/src/reference/source_map.rs b/crates/turbopack-core/src/reference/source_map.rs index 8ec2e6328b3de..d1769011d2428 100644 --- a/crates/turbopack-core/src/reference/source_map.rs +++ b/crates/turbopack-core/src/reference/source_map.rs @@ -2,8 +2,8 @@ use anyhow::Result; use turbo_tasks::{ValueToString, Vc}; use turbo_tasks_fs::{FileSystemEntryType, FileSystemPath}; -use super::AssetReference; -use crate::{file_source::FileSource, resolve::ResolveResult}; +use super::ModuleReference; +use crate::{file_source::FileSource, raw_module::RawModule, resolve::ModuleResolveResult}; #[turbo_tasks::value] pub struct SourceMapReference { @@ -20,16 +20,19 @@ impl SourceMapReference { } #[turbo_tasks::value_impl] -impl AssetReference for SourceMapReference { +impl ModuleReference for SourceMapReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Vc { + async fn resolve_reference(&self) -> Vc { let file_type = self.file.get_type().await; if let Ok(file_type_result) = file_type.as_ref() { if let FileSystemEntryType::File = &**file_type_result { - return ResolveResult::asset(Vc::upcast(FileSource::new(self.file))).into(); + return ModuleResolveResult::module(Vc::upcast(RawModule::new(Vc::upcast( + FileSource::new(self.file), + )))) + .cell(); } } - ResolveResult::unresolveable().into() + ModuleResolveResult::unresolveable().into() } } diff --git a/crates/turbopack-core/src/resolve/mod.rs b/crates/turbopack-core/src/resolve/mod.rs index d4c7a3c4986dd..21116a7cd1a9b 100644 --- a/crates/turbopack-core/src/resolve/mod.rs +++ b/crates/turbopack-core/src/resolve/mod.rs @@ -23,17 +23,19 @@ use self::{ remap::{ExportsField, ImportsField}, }; use crate::{ - asset::{Asset, AssetOption, Assets}, file_source::FileSource, issue::{resolve::ResolvingIssue, IssueExt}, + module::{Module, Modules, OptionModule}, + output::{OutputAsset, OutputAssets}, package_json::{read_package_json, PackageJsonIssue}, - reference::AssetReference, + raw_module::RawModule, + reference::ModuleReference, reference_type::ReferenceType, resolve::{ pattern::{read_matches, PatternMatch}, plugin::ResolvePlugin, }, - source::{asset_to_source, Source}, + source::{OptionSource, Source, Sources}, }; mod alias_map; @@ -54,8 +56,290 @@ use crate::issue::{IssueSeverity, OptionIssueSource}; #[turbo_tasks::value(shared)] #[derive(Clone, Debug)] -pub enum PrimaryResolveResult { - Asset(Vc>), +pub enum ModuleResolveResultItem { + Module(Vc>), + OutputAsset(Vc>), + OriginalReferenceExternal, + OriginalReferenceTypeExternal(String), + Ignore, + Empty, + Custom(u8), + Unresolveable, +} + +#[turbo_tasks::value(shared)] +#[derive(Clone, Debug)] +pub struct ModuleResolveResult { + pub primary: Vec, + pub references: Vec>>, +} + +impl Default for ModuleResolveResult { + fn default() -> Self { + ModuleResolveResult::unresolveable() + } +} + +impl ModuleResolveResult { + pub fn unresolveable() -> Self { + ModuleResolveResult { + primary: Vec::new(), + references: Vec::new(), + } + } + + pub fn unresolveable_with_references( + references: Vec>>, + ) -> ModuleResolveResult { + ModuleResolveResult { + primary: Vec::new(), + references, + } + } + + pub fn module(module: Vc>) -> ModuleResolveResult { + ModuleResolveResult { + primary: vec![ModuleResolveResultItem::Module(module)], + references: Vec::new(), + } + } + + pub fn output_asset(output_asset: Vc>) -> ModuleResolveResult { + ModuleResolveResult { + primary: vec![ModuleResolveResultItem::OutputAsset(output_asset)], + references: Vec::new(), + } + } + + pub fn module_with_references( + module: Vc>, + references: Vec>>, + ) -> ModuleResolveResult { + ModuleResolveResult { + primary: vec![ModuleResolveResultItem::Module(module)], + references, + } + } + + pub fn modules(modules: Vec>>) -> ModuleResolveResult { + ModuleResolveResult { + primary: modules + .into_iter() + .map(ModuleResolveResultItem::Module) + .collect(), + references: Vec::new(), + } + } + + // TODO We don't want output assets to be references from modules + pub fn output_assets(output_assets: Vec>>) -> ModuleResolveResult { + ModuleResolveResult { + primary: output_assets + .into_iter() + .map(ModuleResolveResultItem::OutputAsset) + .collect(), + references: Vec::new(), + } + } + + pub fn modules_with_references( + modules: Vec>>, + references: Vec>>, + ) -> ModuleResolveResult { + ModuleResolveResult { + primary: modules + .into_iter() + .map(ModuleResolveResultItem::Module) + .collect(), + references, + } + } + + pub fn add_reference_ref(&mut self, reference: Vc>) { + self.references.push(reference); + } + + pub fn get_references(&self) -> &Vec>> { + &self.references + } + + fn clone_with_references( + &self, + references: Vec>>, + ) -> ModuleResolveResult { + ModuleResolveResult { + primary: self.primary.clone(), + references, + } + } + + pub fn merge_alternatives(&mut self, other: &ModuleResolveResult) { + self.primary.extend(other.primary.iter().cloned()); + self.references.extend(other.references.iter().copied()); + } + + pub fn is_unresolveable_ref(&self) -> bool { + self.primary.is_empty() + } +} + +#[turbo_tasks::value_impl] +impl ModuleResolveResult { + #[turbo_tasks::function] + pub async fn with_reference( + self: Vc, + reference: Vc>, + ) -> Result> { + let mut this = self.await?.clone_value(); + this.add_reference_ref(reference); + Ok(this.into()) + } + + #[turbo_tasks::function] + pub async fn with_references( + self: Vc, + references: Vec>>, + ) -> Result> { + let mut this = self.await?.clone_value(); + for reference in references { + this.add_reference_ref(reference); + } + Ok(this.into()) + } + + /// Returns the first [ModuleResolveResult] that is not + /// [ModuleResolveResult::Unresolveable] in the given list, while keeping + /// track of all the references in all the [ModuleResolveResult]s. + #[turbo_tasks::function] + pub async fn select_first(results: Vec>) -> Result> { + let mut references = vec![]; + for result in &results { + references.extend(result.await?.get_references()); + } + for result in results { + let result_ref = result.await?; + if !result_ref.is_unresolveable_ref() { + return Ok(result_ref.clone_with_references(references).cell()); + } + } + Ok(ModuleResolveResult::unresolveable_with_references(references).into()) + } + + #[turbo_tasks::function] + pub async fn alternatives(results: Vec>) -> Result> { + if results.len() == 1 { + return Ok(results.into_iter().next().unwrap()); + } + let mut iter = results.into_iter().try_join().await?.into_iter(); + if let Some(current) = iter.next() { + let mut current = current.clone_value(); + for result in iter { + // For clippy -- This explicit deref is necessary + let other = &*result; + current.merge_alternatives(other); + } + Ok(Self::cell(current)) + } else { + Ok(Self::cell(ModuleResolveResult::unresolveable())) + } + } + + #[turbo_tasks::function] + pub async fn alternatives_with_references( + results: Vec>, + references: Vec>>, + ) -> Result> { + if references.is_empty() { + return Ok(Self::alternatives(results)); + } + if results.len() == 1 { + return Ok(results + .into_iter() + .next() + .unwrap() + .with_references(references)); + } + let mut iter = results.into_iter().try_join().await?.into_iter(); + if let Some(current) = iter.next() { + let mut current = current.clone_value(); + for result in iter { + // For clippy -- This explicit deref is necessary + let other = &*result; + current.merge_alternatives(other); + } + current.references.extend(references); + Ok(Self::cell(current)) + } else { + Ok(Self::cell( + ModuleResolveResult::unresolveable_with_references(references), + )) + } + } + + #[turbo_tasks::function] + pub async fn is_unresolveable(self: Vc) -> Result> { + let this = self.await?; + Ok(Vc::cell(this.is_unresolveable_ref())) + } + + #[turbo_tasks::function] + pub async fn first_module(self: Vc) -> Result> { + let this = self.await?; + Ok(Vc::cell(this.primary.iter().find_map(|item| match *item { + ModuleResolveResultItem::Module(a) => Some(a), + _ => None, + }))) + } + + #[turbo_tasks::function] + pub async fn primary_modules(self: Vc) -> Result> { + let this = self.await?; + Ok(Vc::cell( + this.primary + .iter() + .filter_map(|item| match *item { + ModuleResolveResultItem::Module(a) => Some(a), + _ => None, + }) + .collect(), + )) + } + + #[turbo_tasks::function] + pub async fn primary_output_assets(self: Vc) -> Result> { + let this = self.await?; + Ok(Vc::cell( + this.primary + .iter() + .filter_map(|item| match *item { + ModuleResolveResultItem::OutputAsset(a) => Some(a), + _ => None, + }) + .collect(), + )) + } +} + +#[turbo_tasks::value(transparent)] +pub struct ModuleResolveResultOption(Option>); + +#[turbo_tasks::value_impl] +impl ModuleResolveResultOption { + #[turbo_tasks::function] + pub fn some(result: Vc) -> Vc { + ModuleResolveResultOption(Some(result)).cell() + } + + #[turbo_tasks::function] + pub fn none() -> Vc { + ModuleResolveResultOption(None).cell() + } +} + +#[turbo_tasks::value(shared)] +#[derive(Clone, Debug)] +pub enum ResolveResultItem { + Source(Vc>), OriginalReferenceExternal, OriginalReferenceTypeExternal(String), Ignore, @@ -67,8 +351,8 @@ pub enum PrimaryResolveResult { #[turbo_tasks::value(shared)] #[derive(Clone, Debug)] pub struct ResolveResult { - pub primary: Vec, - pub references: Vec>>, + pub primary: Vec, + pub affecting_sources: Vec>>, } impl Default for ResolveResult { @@ -81,106 +365,104 @@ impl ResolveResult { pub fn unresolveable() -> Self { ResolveResult { primary: Vec::new(), - references: Vec::new(), + affecting_sources: Vec::new(), } } - pub fn unresolveable_with_references( - references: Vec>>, + pub fn unresolveable_with_affecting_sources( + affecting_sources: Vec>>, ) -> ResolveResult { ResolveResult { primary: Vec::new(), - references, + affecting_sources, } } - pub fn primary(result: PrimaryResolveResult) -> ResolveResult { + pub fn primary(result: ResolveResultItem) -> ResolveResult { ResolveResult { primary: vec![result], - references: Vec::new(), + affecting_sources: Vec::new(), } } - pub fn primary_with_references( - result: PrimaryResolveResult, - references: Vec>>, + pub fn primary_with_affecting_sources( + result: ResolveResultItem, + affecting_sources: Vec>>, ) -> ResolveResult { ResolveResult { primary: vec![result], - references, + affecting_sources, } } - pub fn asset(asset: Vc>) -> ResolveResult { + pub fn source(source: Vc>) -> ResolveResult { ResolveResult { - primary: vec![PrimaryResolveResult::Asset(asset)], - references: Vec::new(), + primary: vec![ResolveResultItem::Source(source)], + affecting_sources: Vec::new(), } } - pub fn asset_with_references( - asset: Vc>, - references: Vec>>, + pub fn source_with_affecting_sources( + source: Vc>, + affecting_sources: Vec>>, ) -> ResolveResult { ResolveResult { - primary: vec![PrimaryResolveResult::Asset(asset)], - references, + primary: vec![ResolveResultItem::Source(source)], + affecting_sources, } } - pub fn assets(assets: Vec>>) -> ResolveResult { + pub fn sources(sources: Vec>>) -> ResolveResult { ResolveResult { - primary: assets - .into_iter() - .map(PrimaryResolveResult::Asset) - .collect(), - references: Vec::new(), + primary: sources.into_iter().map(ResolveResultItem::Source).collect(), + affecting_sources: Vec::new(), } } - pub fn assets_with_references( - assets: Vec>>, - references: Vec>>, + pub fn sources_with_affecting_sources( + sources: Vec>>, + affecting_sources: Vec>>, ) -> ResolveResult { ResolveResult { - primary: assets - .into_iter() - .map(PrimaryResolveResult::Asset) - .collect(), - references, + primary: sources.into_iter().map(ResolveResultItem::Source).collect(), + affecting_sources, } } - pub fn add_reference_ref(&mut self, reference: Vc>) { - self.references.push(reference); + pub fn add_affecting_source_ref(&mut self, reference: Vc>) { + self.affecting_sources.push(reference); } - pub fn get_references(&self) -> &Vec>> { - &self.references + pub fn get_affecting_sources(&self) -> &Vec>> { + &self.affecting_sources } - fn clone_with_references(&self, references: Vec>>) -> ResolveResult { + fn clone_with_affecting_sources( + &self, + affecting_sources: Vec>>, + ) -> ResolveResult { ResolveResult { primary: self.primary.clone(), - references, + affecting_sources, } } pub fn merge_alternatives(&mut self, other: &ResolveResult) { self.primary.extend(other.primary.iter().cloned()); - self.references.extend(other.references.iter().copied()); + self.affecting_sources + .extend(other.affecting_sources.iter().copied()); } pub fn is_unresolveable_ref(&self) -> bool { self.primary.is_empty() } - pub async fn map(&self, asset_fn: A, reference_fn: R) -> Result + pub async fn map(&self, source_fn: A, affecting_source_fn: R) -> Result where - A: Fn(Vc>) -> AF, - AF: Future>>>, - R: Fn(Vc>) -> RF, - RF: Future>>>, + A: Fn(Vc>) -> AF, + AF: Future>>>, + R: Fn(Vc>) -> RF, + RF: Future>>>, { Ok(Self { primary: self @@ -188,10 +470,10 @@ impl ResolveResult { .iter() .cloned() .map(|result| { - let asset_fn = &asset_fn; + let asset_fn = &source_fn; async move { - if let PrimaryResolveResult::Asset(asset) = result { - Ok(PrimaryResolveResult::Asset(asset_fn(asset).await?)) + if let ResolveResultItem::Source(asset) = result { + Ok(ResolveResultItem::Source(asset_fn(asset).await?)) } else { Ok(result) } @@ -199,11 +481,61 @@ impl ResolveResult { }) .try_join() .await?, + affecting_sources: self + .affecting_sources + .iter() + .copied() + .map(affecting_source_fn) + .try_join() + .await?, + }) + } + + pub async fn map_module( + &self, + source_fn: A, + affected_source_fn: R, + ) -> Result + where + A: Fn(Vc>) -> AF, + AF: Future>>>, + R: Fn(Vc>) -> RF, + RF: Future>>>, + { + Ok(ModuleResolveResult { + primary: self + .primary + .iter() + .cloned() + .map(|item| { + let asset_fn = &source_fn; + async move { + Ok(match item { + ResolveResultItem::Source(source) => { + ModuleResolveResultItem::Module(Vc::upcast(asset_fn(source).await?)) + } + ResolveResultItem::OriginalReferenceExternal => { + ModuleResolveResultItem::OriginalReferenceExternal + } + ResolveResultItem::OriginalReferenceTypeExternal(s) => { + ModuleResolveResultItem::OriginalReferenceTypeExternal(s) + } + ResolveResultItem::Ignore => ModuleResolveResultItem::Ignore, + ResolveResultItem::Empty => ModuleResolveResultItem::Empty, + ResolveResultItem::Custom(u8) => ModuleResolveResultItem::Custom(u8), + ResolveResultItem::Unresolveable => { + ModuleResolveResultItem::Unresolveable + } + }) + } + }) + .try_join() + .await?, references: self - .references + .affecting_sources .iter() .copied() - .map(reference_fn) + .map(affected_source_fn) .try_join() .await?, }) @@ -213,23 +545,38 @@ impl ResolveResult { #[turbo_tasks::value_impl] impl ResolveResult { #[turbo_tasks::function] - pub async fn with_reference( + pub async fn as_raw_module_result(self: Vc) -> Result> { + Ok( + self.await? + .map_module( + |asset| async move { Ok(Vc::upcast(RawModule::new(asset))) }, + |source| async move { + Ok(Vc::upcast(AffectingResolvingAssetReference::new(source))) + }, + ) + .await? + .cell(), + ) + } + + #[turbo_tasks::function] + pub async fn with_affecting_source( self: Vc, - reference: Vc>, + affecting_source: Vc>, ) -> Result> { let mut this = self.await?.clone_value(); - this.add_reference_ref(reference); + this.add_affecting_source_ref(affecting_source); Ok(this.into()) } #[turbo_tasks::function] - pub async fn with_references( + pub async fn with_affecting_sources( self: Vc, - references: Vec>>, + affecting_sources: Vec>>, ) -> Result> { let mut this = self.await?.clone_value(); - for reference in references { - this.add_reference_ref(reference); + for affecting_source in affecting_sources { + this.add_affecting_source_ref(affecting_source); } Ok(this.into()) } @@ -241,15 +588,15 @@ impl ResolveResult { pub async fn select_first(results: Vec>) -> Result> { let mut references = vec![]; for result in &results { - references.extend(result.await?.get_references()); + references.extend(result.await?.get_affecting_sources()); } for result in results { let result_ref = result.await?; if !result_ref.is_unresolveable_ref() { - return Ok(result_ref.clone_with_references(references).cell()); + return Ok(result_ref.clone_with_affecting_sources(references).cell()); } } - Ok(ResolveResult::unresolveable_with_references(references).into()) + Ok(ResolveResult::unresolveable_with_affecting_sources(references).into()) } #[turbo_tasks::function] @@ -272,11 +619,11 @@ impl ResolveResult { } #[turbo_tasks::function] - pub async fn alternatives_with_references( + pub async fn alternatives_with_affecting_sources( results: Vec>, - references: Vec>>, + affecting_sources: Vec>>, ) -> Result> { - if references.is_empty() { + if affecting_sources.is_empty() { return Ok(Self::alternatives(results)); } if results.len() == 1 { @@ -284,7 +631,7 @@ impl ResolveResult { .into_iter() .next() .unwrap() - .with_references(references)); + .with_affecting_sources(affecting_sources)); } let mut iter = results.into_iter().try_join().await?.into_iter(); if let Some(current) = iter.next() { @@ -294,12 +641,12 @@ impl ResolveResult { let other = &*result; current.merge_alternatives(other); } - current.references.extend(references); + current.affecting_sources.extend(affecting_sources); Ok(Self::cell(current)) } else { - Ok(Self::cell(ResolveResult::unresolveable_with_references( - references, - ))) + Ok(Self::cell( + ResolveResult::unresolveable_with_affecting_sources(affecting_sources), + )) } } @@ -310,10 +657,10 @@ impl ResolveResult { } #[turbo_tasks::function] - pub async fn first_asset(self: Vc) -> Result> { + pub async fn first_source(self: Vc) -> Result> { let this = self.await?; Ok(Vc::cell(this.primary.iter().find_map(|item| { - if let PrimaryResolveResult::Asset(a) = item { + if let ResolveResultItem::Source(a) = item { Some(*a) } else { None @@ -322,13 +669,13 @@ impl ResolveResult { } #[turbo_tasks::function] - pub async fn primary_assets(self: Vc) -> Result> { + pub async fn primary_sources(self: Vc) -> Result> { let this = self.await?; Ok(Vc::cell( this.primary .iter() .filter_map(|item| { - if let PrimaryResolveResult::Asset(a) = item { + if let ResolveResultItem::Source(a) = item { Some(*a) } else { None @@ -357,14 +704,14 @@ impl ResolveResultOption { async fn exists( fs_path: Vc, - refs: &mut Vec>>, + refs: &mut Vec>>, ) -> Result>> { type_exists(fs_path, FileSystemEntryType::File, refs).await } async fn dir_exists( fs_path: Vc, - refs: &mut Vec>>, + refs: &mut Vec>>, ) -> Result>> { type_exists(fs_path, FileSystemEntryType::Directory, refs).await } @@ -372,11 +719,11 @@ async fn dir_exists( async fn type_exists( fs_path: Vc, ty: FileSystemEntryType, - refs: &mut Vec>>, + refs: &mut Vec>>, ) -> Result>> { let result = fs_path.resolve().await?.realpath_with_links().await?; for path in result.symlinks.iter() { - refs.push(Vc::upcast(AffectingResolvingAssetReference::new(*path))); + refs.push(Vc::upcast(FileSource::new(*path))); } let path = result.path; Ok(if *path.get_type().await? == ty { @@ -467,8 +814,8 @@ pub fn package_json() -> Vc> { #[turbo_tasks::value(shared)] pub enum FindContextFileResult { - Found(Vc, Vec>>), - NotFound(Vec>>), + Found(Vc, Vec>>), + NotFound(Vec>>), } #[turbo_tasks::function] @@ -509,7 +856,7 @@ pub async fn find_context_file( #[turbo_tasks::value] struct FindPackageResult { packages: Vec>, - references: Vec>>, + affecting_sources: Vec>>, } #[turbo_tasks::function] @@ -519,7 +866,7 @@ async fn find_package( options: Vc, ) -> Result> { let mut packages = vec![]; - let mut references = vec![]; + let mut affecting_sources = vec![]; let options = options.await?; for resolve_modules in &options.modules { match resolve_modules { @@ -531,9 +878,11 @@ async fn find_package( while context_value.is_inside_ref(root) { for name in names.iter() { let fs_path = context.join(name.clone()); - if let Some(fs_path) = dir_exists(fs_path, &mut references).await? { + if let Some(fs_path) = dir_exists(fs_path, &mut affecting_sources).await? { let fs_path = fs_path.join(package_name.clone()); - if let Some(fs_path) = dir_exists(fs_path, &mut references).await? { + if let Some(fs_path) = + dir_exists(fs_path, &mut affecting_sources).await? + { packages.push(fs_path); } } @@ -548,7 +897,10 @@ async fn find_package( } ResolveModules::Path(context) => { let package_dir = context.join(package_name.clone()); - if dir_exists(package_dir, &mut references).await?.is_some() { + if dir_exists(package_dir, &mut affecting_sources) + .await? + .is_some() + { packages.push(package_dir.resolve().await?); } } @@ -557,7 +909,7 @@ async fn find_package( } Ok(FindPackageResult::cell(FindPackageResult { packages, - references, + affecting_sources, })) } @@ -569,21 +921,21 @@ fn merge_results(results: Vec>) -> Vc { } } -fn merge_results_with_references( +fn merge_results_with_affecting_sources( results: Vec>, - references: Vec>>, + affecting_sources: Vec>>, ) -> Vc { - if references.is_empty() { + if affecting_sources.is_empty() { return merge_results(results); } match results.len() { - 0 => ResolveResult::unresolveable_with_references(references).into(), + 0 => ResolveResult::unresolveable_with_affecting_sources(affecting_sources).into(), 1 => results .into_iter() .next() .unwrap() - .with_references(references), - _ => ResolveResult::alternatives_with_references(results, references), + .with_affecting_sources(affecting_sources), + _ => ResolveResult::alternatives_with_affecting_sources(results, affecting_sources), } } @@ -595,14 +947,14 @@ pub async fn resolve_raw( ) -> Result> { async fn to_result(path: Vc) -> Result> { let RealPathResult { path, symlinks } = &*path.realpath_with_links().await?; - Ok(ResolveResult::asset_with_references( + Ok(ResolveResult::source_with_affecting_sources( Vc::upcast(FileSource::new(*path)), symlinks .iter() - .map(|p| Vc::upcast(AffectingResolvingAssetReference::new(*p))) + .map(|p| Vc::upcast(FileSource::new(*p))) .collect(), ) - .into()) + .cell()) } let mut results = Vec::new(); let pat = path.await?; @@ -686,10 +1038,9 @@ async fn handle_resolve_plugins( let mut new_references = Vec::new(); for primary in result_value.primary.iter() { - if let &PrimaryResolveResult::Asset(asset) = primary { - let asset = asset_to_source(asset); + if let &ResolveResultItem::Source(source) = primary { if let Some(new_result) = apply_plugins_to_path( - asset.ident().path().resolve().await?, + source.ident().path().resolve().await?, context, request, options, @@ -699,7 +1050,7 @@ async fn handle_resolve_plugins( let new_result = new_result.await?; changed = true; new_primary.extend(new_result.primary.iter().cloned()); - new_references.extend(new_result.references.iter().copied()); + new_references.extend(new_result.affecting_sources.iter().copied()); } else { new_primary.push(primary.clone()); } @@ -712,12 +1063,12 @@ async fn handle_resolve_plugins( return Ok(result); } - let mut references = result_value.references.clone(); - references.append(&mut new_references); + let mut affecting_sources = result_value.affecting_sources.clone(); + affecting_sources.append(&mut new_references); Ok(ResolveResult { primary: new_primary, - references, + affecting_sources, } .cell()) } @@ -881,9 +1232,10 @@ async fn resolve_internal( Request::Uri { protocol, remainder, - } => ResolveResult::primary(PrimaryResolveResult::OriginalReferenceTypeExternal( - format!("{}{}", protocol, remainder), - )) + } => ResolveResult::primary(ResolveResultItem::OriginalReferenceTypeExternal(format!( + "{}{}", + protocol, remainder + ))) .into(), Request::Unknown { path } => { ResolvingIssue { @@ -947,9 +1299,9 @@ async fn resolve_into_folder( // we continue to try other alternatives if !result.is_unresolveable_ref() { let mut result = result.clone(); - result.add_reference_ref(Vc::upcast( - AffectingResolvingAssetReference::new(package_json_path), - )); + result.add_affecting_source_ref(Vc::upcast(FileSource::new( + package_json_path, + ))); return Ok(result.into()); } } @@ -1034,7 +1386,10 @@ async fn resolve_module_request( .await?; if result.packages.is_empty() { - return Ok(ResolveResult::unresolveable_with_references(result.references.clone()).into()); + return Ok(ResolveResult::unresolveable_with_affecting_sources( + result.affecting_sources.clone(), + ) + .into()); } let mut results = vec![]; @@ -1094,9 +1449,9 @@ async fn resolve_module_request( } } - Ok(merge_results_with_references( + Ok(merge_results_with_affecting_sources( results, - result.references.clone(), + result.affecting_sources.clone(), )) } @@ -1160,7 +1515,7 @@ fn resolve_import_map_result_boxed<'a>( async fn resolve_alias_field_result( result: &JsonValue, - refs: Vec>>, + refs: Vec>>, package_path: Vc, resolve_options: Vc, issue_context: Vc, @@ -1169,7 +1524,7 @@ async fn resolve_alias_field_result( ) -> Result> { if result.as_bool() == Some(false) { return Ok( - ResolveResult::primary_with_references(PrimaryResolveResult::Ignore, refs).cell(), + ResolveResult::primary_with_affecting_sources(ResolveResultItem::Ignore, refs).cell(), ); } if let Some(value) = result.as_str() { @@ -1178,7 +1533,7 @@ async fn resolve_alias_field_result( Request::parse(Value::new(Pattern::Constant(value.to_string()))), resolve_options, ) - .with_references(refs)); + .with_affecting_sources(refs)); } ResolvingIssue { severity: IssueSeverity::Error.cell(), @@ -1191,7 +1546,7 @@ async fn resolve_alias_field_result( } .cell() .emit(); - Ok(ResolveResult::unresolveable_with_references(refs).cell()) + Ok(ResolveResult::unresolveable_with_affecting_sources(refs).cell()) } async fn resolved( @@ -1260,11 +1615,11 @@ async fn resolved( } } - Ok(ResolveResult::asset_with_references( + Ok(ResolveResult::source_with_affecting_sources( Vc::upcast(FileSource::new(*path)), symlinks .iter() - .map(|p| Vc::upcast(AffectingResolvingAssetReference::new(*p))) + .map(|p| Vc::upcast(FileSource::new(*p))) .collect(), ) .into()) @@ -1307,11 +1662,9 @@ fn handle_exports_imports_field( } } // other options do not apply anymore when an exports field exist - Ok(merge_results_with_references( + Ok(merge_results_with_affecting_sources( resolved_results, - vec![Vc::upcast(AffectingResolvingAssetReference::new( - package_json_path, - ))], + vec![Vc::upcast(FileSource::new(package_json_path))], )) } @@ -1365,22 +1718,22 @@ async fn resolve_package_internal_with_imports_field( #[turbo_tasks::value] pub struct AffectingResolvingAssetReference { - path: Vc, + source: Vc>, } #[turbo_tasks::value_impl] impl AffectingResolvingAssetReference { #[turbo_tasks::function] - pub fn new(path: Vc) -> Vc { - Self::cell(AffectingResolvingAssetReference { path }) + pub fn new(source: Vc>) -> Vc { + Self::cell(AffectingResolvingAssetReference { source }) } } #[turbo_tasks::value_impl] -impl AssetReference for AffectingResolvingAssetReference { +impl ModuleReference for AffectingResolvingAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(FileSource::new(self.path))).into() + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(Vc::upcast(RawModule::new(self.source))).into() } } @@ -1390,20 +1743,20 @@ impl ValueToString for AffectingResolvingAssetReference { async fn to_string(&self) -> Result> { Ok(Vc::cell(format!( "resolving is affected by {}", - self.path.to_string().await? + self.source.ident().to_string().await? ))) } } pub async fn handle_resolve_error( - result: Vc, + result: Vc, reference_type: Value, origin_path: Vc, request: Vc, resolve_options: Vc, source: Vc, severity: Vc, -) -> Result> { +) -> Result> { Ok(match result.is_unresolveable().await { Ok(unresolveable) => { if *unresolveable { @@ -1433,7 +1786,7 @@ pub async fn handle_resolve_error( } .cell() .emit(); - ResolveResult::unresolveable().into() + ModuleResolveResult::unresolveable().cell() } }) } diff --git a/crates/turbopack-core/src/resolve/options.rs b/crates/turbopack-core/src/resolve/options.rs index b13992c387371..581375b44398c 100644 --- a/crates/turbopack-core/src/resolve/options.rs +++ b/crates/turbopack-core/src/resolve/options.rs @@ -9,7 +9,7 @@ use turbo_tasks_fs::{glob::Glob, FileSystemPath}; use super::{ alias_map::{AliasMap, AliasTemplate}, - AliasPattern, PrimaryResolveResult, ResolveResult, + AliasPattern, ResolveResult, ResolveResultItem, }; use crate::resolve::{parse::Request, plugin::ResolvePlugin}; @@ -269,20 +269,17 @@ async fn import_mapping_to_result( Ok(match &*mapping.await? { ImportMapping::Direct(result) => ImportMapResult::Result(*result), ImportMapping::External(name) => ImportMapResult::Result( - ResolveResult::primary_with_references( - name.as_ref().map_or_else( - || PrimaryResolveResult::OriginalReferenceExternal, - |req| PrimaryResolveResult::OriginalReferenceTypeExternal(req.to_string()), - ), - Vec::new(), - ) + ResolveResult::primary(name.as_ref().map_or_else( + || ResolveResultItem::OriginalReferenceExternal, + |req| ResolveResultItem::OriginalReferenceTypeExternal(req.to_string()), + )) .into(), ), ImportMapping::Ignore => { - ImportMapResult::Result(ResolveResult::primary(PrimaryResolveResult::Ignore).into()) + ImportMapResult::Result(ResolveResult::primary(ResolveResultItem::Ignore).into()) } ImportMapping::Empty => { - ImportMapResult::Result(ResolveResult::primary(PrimaryResolveResult::Empty).into()) + ImportMapResult::Result(ResolveResult::primary(ResolveResultItem::Empty).into()) } ImportMapping::PrimaryAlternative(name, context) => { let request = Request::parse(Value::new(name.to_string().into())); diff --git a/crates/turbopack-core/src/resolve/origin.rs b/crates/turbopack-core/src/resolve/origin.rs index fbed76ff35811..8e36cb58e7822 100644 --- a/crates/turbopack-core/src/resolve/origin.rs +++ b/crates/turbopack-core/src/resolve/origin.rs @@ -2,7 +2,7 @@ use anyhow::Result; use turbo_tasks::{Upcast, Value, Vc}; use turbo_tasks_fs::FileSystemPath; -use super::{options::ResolveOptions, parse::Request, ResolveResult}; +use super::{options::ResolveOptions, parse::Request, ModuleResolveResult}; use crate::{context::AssetContext, module::OptionModule, reference_type::ReferenceType}; /// A location where resolving can occur from. It carries some meta information @@ -38,7 +38,7 @@ pub trait ResolveOriginExt { request: Vc, options: Vc, reference_type: Value, - ) -> Vc; + ) -> Vc; /// Get the resolve options that apply for this origin. fn resolve_options(self: Vc, reference_type: Value) -> Vc; @@ -56,7 +56,7 @@ where request: Vc, options: Vc, reference_type: Value, - ) -> Vc { + ) -> Vc { resolve_asset(Vc::upcast(self), request, options, reference_type) } @@ -82,9 +82,9 @@ async fn resolve_asset( request: Vc, options: Vc, reference_type: Value, -) -> Result> { +) -> Result> { if let Some(asset) = *resolve_origin.get_inner_asset(request).await? { - return Ok(ResolveResult::asset(Vc::upcast(asset)).cell()); + return Ok(ModuleResolveResult::module(asset).cell()); } Ok(resolve_origin.context().resolve_asset( resolve_origin.origin_path(), diff --git a/crates/turbopack-core/src/source.rs b/crates/turbopack-core/src/source.rs index 6b6a6f677605e..6fd9e77000bd9 100644 --- a/crates/turbopack-core/src/source.rs +++ b/crates/turbopack-core/src/source.rs @@ -1,10 +1,6 @@ -use anyhow::{Context, Result}; use turbo_tasks::Vc; -use crate::{ - asset::{Asset, AssetOption}, - ident::AssetIdent, -}; +use crate::{asset::Asset, ident::AssetIdent}; /// (Unparsed) Source Code. Source Code is processed into [Module]s by the /// [AssetContext]. All [Source]s have content and an identifier. @@ -21,30 +17,4 @@ pub struct OptionSource(Option>>); #[turbo_tasks::value(transparent)] pub struct Sources(Vec>>); -/// This is a temporary function that should be removed once the [Source] trait -/// completely replaces the [Asset] trait. -/// TODO make this function unnecessary -#[turbo_tasks::function] -pub async fn asset_to_source(asset: Vc>) -> Result>> { - Vc::try_resolve_sidecast::>(asset) - .await? - .context("Asset must be a Source") -} - -/// This is a temporary function that should be removed once the [Source] trait -/// completely replaces the [Asset] trait. -/// TODO make this function unnecessary -#[turbo_tasks::function] -pub async fn option_asset_to_source(asset: Vc) -> Result> { - if let Some(asset) = *asset.await? { - Ok(Vc::cell(Some( - Vc::try_resolve_sidecast::>(asset) - .await? - .context("Asset must be a Source")?, - ))) - } else { - Ok(Vc::cell(None)) - } -} - // TODO All Vc::try_resolve_downcast::> calls should be removed diff --git a/crates/turbopack-core/src/virtual_output.rs b/crates/turbopack-core/src/virtual_output.rs index f3418eb016cc4..21478f9410f3a 100644 --- a/crates/turbopack-core/src/virtual_output.rs +++ b/crates/turbopack-core/src/virtual_output.rs @@ -7,7 +7,7 @@ use crate::{ output::OutputAsset, }; -/// An [Asset] that is created from some passed source code. +/// An [OutputAsset] that is created from some passed source code. #[turbo_tasks::value] pub struct VirtualOutputAsset { pub path: Vc, diff --git a/crates/turbopack-core/src/virtual_source.rs b/crates/turbopack-core/src/virtual_source.rs index 8b0378dc85220..a92724d94f0ba 100644 --- a/crates/turbopack-core/src/virtual_source.rs +++ b/crates/turbopack-core/src/virtual_source.rs @@ -7,7 +7,7 @@ use crate::{ source::Source, }; -/// An [Asset] that is created from some passed source code. +/// A [Source] that is created from some passed source code. #[turbo_tasks::value] pub struct VirtualSource { pub ident: Vc, diff --git a/crates/turbopack-css/src/asset.rs b/crates/turbopack-css/src/asset.rs index 90add35589b09..ed377d7e17beb 100644 --- a/crates/turbopack-css/src/asset.rs +++ b/crates/turbopack-css/src/asset.rs @@ -17,8 +17,8 @@ use turbopack_core::{ context::AssetContext, ident::AssetIdent, module::Module, - reference::{AssetReference, AssetReferences}, - resolve::{origin::ResolveOrigin, PrimaryResolveResult}, + reference::{ModuleReference, ModuleReferences}, + resolve::origin::ResolveOrigin, source::Source, }; @@ -89,7 +89,7 @@ impl Module for CssModuleAsset { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; // TODO: include CSS source map Ok(analyze_css_stylesheet( @@ -162,7 +162,7 @@ impl ChunkItem for CssModuleChunkItem { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.module.references() } } @@ -179,28 +179,34 @@ impl CssChunkItem for CssModuleChunkItem { if let Some(import_ref) = Vc::try_resolve_downcast_type::(*reference).await? { - for result in import_ref.resolve_reference().await?.primary.iter() { - if let PrimaryResolveResult::Asset(asset) = result { - if let Some(placeable) = - Vc::try_resolve_sidecast::>(*asset).await? - { - imports.push(CssImport::Internal( - import_ref, - placeable.as_chunk_item(context), - )); - } + for &module in import_ref + .resolve_reference() + .primary_modules() + .await? + .iter() + { + if let Some(placeable) = + Vc::try_resolve_downcast::>(module).await? + { + imports.push(CssImport::Internal( + import_ref, + placeable.as_chunk_item(context), + )); } } } else if let Some(compose_ref) = Vc::try_resolve_downcast_type::(*reference).await? { - for result in compose_ref.resolve_reference().await?.primary.iter() { - if let PrimaryResolveResult::Asset(asset) = result { - if let Some(placeable) = - Vc::try_resolve_sidecast::>(*asset).await? - { - imports.push(CssImport::Composes(placeable.as_chunk_item(context))); - } + for &module in compose_ref + .resolve_reference() + .primary_modules() + .await? + .iter() + { + if let Some(placeable) = + Vc::try_resolve_downcast::>(module).await? + { + imports.push(CssImport::Composes(placeable.as_chunk_item(context))); } } } diff --git a/crates/turbopack-css/src/chunk/mod.rs b/crates/turbopack-css/src/chunk/mod.rs index 4dc9e43d5accc..bed67556231e0 100644 --- a/crates/turbopack-css/src/chunk/mod.rs +++ b/crates/turbopack-css/src/chunk/mod.rs @@ -18,12 +18,13 @@ use turbopack_core::{ code_builder::{Code, CodeBuilder}, ident::AssetIdent, introspect::{ - asset::{children_from_output_assets, content_to_details, IntrospectableAsset}, + module::IntrospectableModule, + utils::{children_from_output_assets, content_to_details}, Introspectable, IntrospectableChildren, }, module::Module, output::{OutputAsset, OutputAssets}, - reference::AssetReference, + reference::ModuleReference, source_map::{GenerateSourceMap, OptionSourceMap}, }; use writer::expand_imports; @@ -192,7 +193,7 @@ impl GenerateSourceMap for CssChunkContent { pub struct CssChunkContentResult { pub chunk_items: Vec>>, pub chunks: Vec>>, - pub external_asset_references: Vec>>, + pub external_module_references: Vec>>, } impl From>>> for CssChunkContentResult { @@ -200,7 +201,7 @@ impl From>>> for CssChunkContentResu CssChunkContentResult { chunk_items: from.chunk_items, chunks: from.chunks, - external_asset_references: from.external_asset_references, + external_module_references: from.external_module_references, } } } @@ -224,23 +225,23 @@ async fn css_chunk_content( let mut all_chunk_items = IndexSet::>>::new(); let mut all_chunks = IndexSet::>>::new(); - let mut all_external_asset_references = IndexSet::>>::new(); + let mut all_external_module_references = IndexSet::>>::new(); for content in contents { let CssChunkContentResult { chunk_items, chunks, - external_asset_references, + external_module_references, } = &*content.await?; all_chunk_items.extend(chunk_items.iter().copied()); all_chunks.extend(chunks.iter().copied()); - all_external_asset_references.extend(external_asset_references.iter().copied()); + all_external_module_references.extend(external_module_references.iter().copied()); } Ok(CssChunkContentResult { chunk_items: all_chunk_items.into_iter().collect(), chunks: all_chunks.into_iter().collect(), - external_asset_references: all_external_asset_references.into_iter().collect(), + external_module_references: all_external_module_references.into_iter().collect(), } .cell()) } @@ -397,16 +398,24 @@ impl OutputAsset for CssChunk { ) .await?; let mut references = Vec::new(); - let assets = content - .external_asset_references + let output_assets = content + .external_module_references .iter() - .map(|r| r.resolve_reference().primary_assets()) + .map(|r| r.resolve_reference().primary_output_assets()) .try_join() .await?; - for &asset in assets.iter().flatten() { + for &asset in output_assets.iter().flatten() { if let Some(output_asset) = Vc::try_resolve_downcast(asset).await? { references.push(output_asset); } + } + let modules = content + .external_module_references + .iter() + .map(|r| r.resolve_reference().primary_modules()) + .try_join() + .await?; + for &asset in modules.iter().flatten() { if let Some(embeddable) = Vc::try_resolve_sidecast::>(asset).await? { @@ -578,7 +587,7 @@ impl Introspectable for CssChunk { for &entry in &*self.await?.main_entries.await? { children.insert(( entry_module_key(), - IntrospectableAsset::new(Vc::upcast(entry)), + IntrospectableModule::new(Vc::upcast(entry)), )); } Ok(Vc::cell(children)) diff --git a/crates/turbopack-css/src/code_gen.rs b/crates/turbopack-css/src/code_gen.rs index 5af2388bf7d96..69b9a47813d0f 100644 --- a/crates/turbopack-css/src/code_gen.rs +++ b/crates/turbopack-css/src/code_gen.rs @@ -4,7 +4,7 @@ use turbopack_core::chunk::ChunkingContext; use crate::chunk::CssImport; -/// impl of code generation inferred from a AssetReference. +/// impl of code generation inferred from a ModuleReference. /// This is rust only and can't be implemented by non-rust plugins. #[turbo_tasks::value( shared, diff --git a/crates/turbopack-css/src/embed.rs b/crates/turbopack-css/src/embed.rs index 995544c9350b3..5ec4b45a70f4e 100644 --- a/crates/turbopack-css/src/embed.rs +++ b/crates/turbopack-css/src/embed.rs @@ -15,7 +15,7 @@ pub trait CssEmbeddable: ChunkableModule + Module + Asset { #[turbo_tasks::value_trait] pub trait CssEmbed { /// A [CssEmbed] can describe different `references` than its original - /// [Asset]. + /// [Module]. /// TODO(alexkirsz) This should have a default impl that returns empty /// references. fn references(self: Vc) -> Vc; diff --git a/crates/turbopack-css/src/global_asset.rs b/crates/turbopack-css/src/global_asset.rs index 6531ce1452d60..208a7eb440cc8 100644 --- a/crates/turbopack-css/src/global_asset.rs +++ b/crates/turbopack-css/src/global_asset.rs @@ -2,11 +2,11 @@ use anyhow::{bail, Result}; use turbo_tasks::{Value, Vc}; use turbopack_core::{ asset::{Asset, AssetContent}, - chunk::PassthroughAsset, + chunk::PassthroughModule, context::AssetContext, ident::AssetIdent, module::Module, - reference::AssetReferences, + reference::ModuleReferences, reference_type::{CssReferenceSubType, ReferenceType}, source::Source, }; @@ -53,7 +53,7 @@ impl Module for GlobalCssAsset { } #[turbo_tasks::function] - fn references(self: Vc) -> Vc { + fn references(self: Vc) -> Vc { Vc::cell(vec![Vc::upcast(InternalCssAssetReference::new( self.inner(), ))]) @@ -75,4 +75,4 @@ fn modifier() -> Vc { /// A GlobalAsset is a transparent wrapper around an actual CSS asset. #[turbo_tasks::value_impl] -impl PassthroughAsset for GlobalCssAsset {} +impl PassthroughModule for GlobalCssAsset {} diff --git a/crates/turbopack-css/src/module_asset.rs b/crates/turbopack-css/src/module_asset.rs index a80b79512ba1e..5d1e108958cc1 100644 --- a/crates/turbopack-css/src/module_asset.rs +++ b/crates/turbopack-css/src/module_asset.rs @@ -18,7 +18,7 @@ use turbopack_core::{ ident::AssetIdent, issue::{Issue, IssueExt, IssueSeverity}, module::Module, - reference::{AssetReference, AssetReferences}, + reference::{ModuleReference, ModuleReferences}, reference_type::{CssReferenceSubType, ReferenceType}, resolve::{origin::ResolveOrigin, parse::Request}, source::Source, @@ -68,7 +68,7 @@ impl Module for ModuleCssAsset { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { // The inner reference must come first so it is processed before other potential // references inside of the CSS, like `@import` and `composes:`. // This affects the order in which the resulting CSS chunks will be loaded: @@ -187,7 +187,7 @@ impl ModuleCssAsset { } #[turbo_tasks::function] - async fn module_references(self: Vc) -> Result> { + async fn module_references(self: Vc) -> Result> { let mut references = vec![]; for (_, class_names) in &*self.classes().await? { @@ -270,7 +270,7 @@ impl ChunkItem for ModuleChunkItem { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.module.references() } } @@ -296,7 +296,7 @@ impl EcmascriptChunkItem for ModuleChunkItem { original: original_name, from, } => { - let resolved_module = from.resolve_reference().first_asset().await?; + let resolved_module = from.resolve_reference().first_module().await?; let Some(resolved_module) = &*resolved_module else { CssModuleComposesIssue { diff --git a/crates/turbopack-css/src/references/compose.rs b/crates/turbopack-css/src/references/compose.rs index beeb66a83d0f3..8a23bcda76a54 100644 --- a/crates/turbopack-css/src/references/compose.rs +++ b/crates/turbopack-css/src/references/compose.rs @@ -3,9 +3,9 @@ use turbo_tasks::{Value, ValueToString, Vc}; use turbopack_core::{ chunk::ChunkableModuleReference, issue::OptionIssueSource, - reference::AssetReference, + reference::ModuleReference, reference_type::CssReferenceSubType, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use crate::references::css_resolve; @@ -28,9 +28,9 @@ impl CssModuleComposeReference { } #[turbo_tasks::value_impl] -impl AssetReference for CssModuleComposeReference { +impl ModuleReference for CssModuleComposeReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { css_resolve( self.origin, self.request, diff --git a/crates/turbopack-css/src/references/import.rs b/crates/turbopack-css/src/references/import.rs index 180c76d689ba1..c498f6e384884 100644 --- a/crates/turbopack-css/src/references/import.rs +++ b/crates/turbopack-css/src/references/import.rs @@ -13,9 +13,9 @@ use turbo_tasks::{Value, ValueToString, Vc}; use turbopack_core::{ chunk::{ChunkableModuleReference, ChunkingContext}, issue::{IssueSource, OptionIssueSource}, - reference::AssetReference, + reference::ModuleReference, reference_type::CssReferenceSubType, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use crate::{ @@ -211,9 +211,9 @@ impl ImportAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for ImportAssetReference { +impl ModuleReference for ImportAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { css_resolve( self.origin, self.request, diff --git a/crates/turbopack-css/src/references/internal.rs b/crates/turbopack-css/src/references/internal.rs index 43fcc039099eb..d2f9bd560f906 100644 --- a/crates/turbopack-css/src/references/internal.rs +++ b/crates/turbopack-css/src/references/internal.rs @@ -1,8 +1,8 @@ use anyhow::Result; use turbo_tasks::{ValueToString, Vc}; use turbopack_core::{ - chunk::ChunkableModuleReference, module::Module, reference::AssetReference, - resolve::ResolveResult, + chunk::ChunkableModuleReference, module::Module, reference::ModuleReference, + resolve::ModuleResolveResult, }; /// A reference to an internal CSS asset. @@ -22,10 +22,10 @@ impl InternalCssAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for InternalCssAssetReference { +impl ModuleReference for InternalCssAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(self.module)).cell() + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(self.module).cell() } } diff --git a/crates/turbopack-css/src/references/mod.rs b/crates/turbopack-css/src/references/mod.rs index 6fe9a66d720b2..831504b1e01c8 100644 --- a/crates/turbopack-css/src/references/mod.rs +++ b/crates/turbopack-css/src/references/mod.rs @@ -13,13 +13,13 @@ use swc_core::{ use turbo_tasks::{Value, Vc}; use turbopack_core::{ issue::{IssueSeverity, IssueSource, OptionIssueSource}, - reference::{AssetReference, AssetReferences}, + reference::{ModuleReference, ModuleReferences}, reference_type::{CssReferenceSubType, ReferenceType}, resolve::{ handle_resolve_error, origin::{ResolveOrigin, ResolveOriginExt}, parse::Request, - ResolveResult, + ModuleResolveResult, }, source::Source, }; @@ -45,7 +45,7 @@ pub async fn analyze_css_stylesheet( origin: Vc>, ty: CssModuleAssetType, transforms: Vc, -) -> Result> { +) -> Result> { let mut references = Vec::new(); let parsed = parse_css(source, ty, transforms).await?; @@ -69,7 +69,7 @@ pub async fn analyze_css_stylesheet( HANDLER.set(&handler, || { GLOBALS.set(&globals, || { // TODO migrate to effects - let mut visitor = AssetReferencesVisitor::new(source, origin, &mut references); + let mut visitor = ModuleReferencesVisitor::new(source, origin, &mut references); stylesheet.visit_with_path(&mut visitor, &mut Default::default()); }) }); @@ -77,18 +77,18 @@ pub async fn analyze_css_stylesheet( Ok(Vc::cell(references)) } -struct AssetReferencesVisitor<'a> { +struct ModuleReferencesVisitor<'a> { source: Vc>, origin: Vc>, - references: &'a mut Vec>>, + references: &'a mut Vec>>, is_import: bool, } -impl<'a> AssetReferencesVisitor<'a> { +impl<'a> ModuleReferencesVisitor<'a> { fn new( source: Vc>, origin: Vc>, - references: &'a mut Vec>>, + references: &'a mut Vec>>, ) -> Self { Self { source, @@ -114,7 +114,7 @@ pub fn as_parent_path(ast_path: &AstNodePath<'_>) -> Vec { ast_path.iter().map(|n| n.kind()).collect() } -impl<'a> VisitAstPath for AssetReferencesVisitor<'a> { +impl<'a> VisitAstPath for ModuleReferencesVisitor<'a> { fn visit_import_prelude<'ast: 'r, 'r>( &mut self, i: &'ast ImportPrelude, @@ -178,7 +178,7 @@ pub async fn css_resolve( request: Vc, ty: Value, issue_source: Vc, -) -> Result> { +) -> Result> { let ty = Value::new(ReferenceType::Css(ty.into_value())); let options = origin.resolve_options(ty.clone()); let result = origin.resolve_asset(request, options, ty.clone()); diff --git a/crates/turbopack-css/src/references/url.rs b/crates/turbopack-css/src/references/url.rs index 52110be05cd12..b6ef7abafcf2a 100644 --- a/crates/turbopack-css/src/references/url.rs +++ b/crates/turbopack-css/src/references/url.rs @@ -9,9 +9,9 @@ use turbopack_core::{ ident::AssetIdent, issue::{IssueSeverity, IssueSource}, output::OutputAsset, - reference::AssetReference, + reference::ModuleReference, reference_type::UrlReferenceSubType, - resolve::{origin::ResolveOrigin, parse::Request, PrimaryResolveResult, ResolveResult}, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use turbopack_ecmascript::resolve::url_resolve; @@ -59,16 +59,14 @@ impl UrlAssetReference { self: Vc, context: Vc>, ) -> Result> { - for result in self.resolve_reference().await?.primary.iter() { - if let PrimaryResolveResult::Asset(asset) = result { - if let Some(embeddable) = - Vc::try_resolve_sidecast::>(*asset).await? - { - return Ok(ReferencedAsset::Some( - embeddable.as_css_embed(context).embeddable_asset(), - ) - .into()); - } + for &module in self.resolve_reference().primary_modules().await?.iter() { + if let Some(embeddable) = + Vc::try_resolve_sidecast::>(module).await? + { + return Ok(ReferencedAsset::Some( + embeddable.as_css_embed(context).embeddable_asset(), + ) + .into()); } } Ok(ReferencedAsset::cell(ReferencedAsset::None)) @@ -76,9 +74,9 @@ impl UrlAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for UrlAssetReference { +impl ModuleReference for UrlAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { url_resolve( self.origin, self.request, diff --git a/crates/turbopack-dev-server/src/html.rs b/crates/turbopack-dev-server/src/html.rs index 46725262d134b..0b8ecb375af9c 100644 --- a/crates/turbopack-dev-server/src/html.rs +++ b/crates/turbopack-dev-server/src/html.rs @@ -129,9 +129,9 @@ impl DevHtmlAsset { .entries .iter() .map(|entry| async move { - let (chunkable_asset, chunking_context, runtime_entries) = entry; + let (chunkable_module, chunking_context, runtime_entries) = entry; - let chunk = chunkable_asset.as_root_chunk(*chunking_context); + let chunk = chunkable_module.as_root_chunk(*chunking_context); let assets = if let Some(runtime_entries) = runtime_entries { chunking_context.evaluated_chunk_group(chunk, *runtime_entries) } else { diff --git a/crates/turbopack-dev-server/src/source/asset_graph.rs b/crates/turbopack-dev-server/src/source/asset_graph.rs index 8c798dabf0413..5109ef90514d8 100644 --- a/crates/turbopack-dev-server/src/source/asset_graph.rs +++ b/crates/turbopack-dev-server/src/source/asset_graph.rs @@ -9,7 +9,7 @@ use turbo_tasks::{Completion, State, Value, ValueToString, Vc}; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ asset::Asset, - introspect::{asset::IntrospectableAsset, Introspectable, IntrospectableChildren}, + introspect::{output_asset::IntrospectableOutputAsset, Introspectable, IntrospectableChildren}, output::{OutputAsset, OutputAssetsSet}, }; @@ -287,13 +287,18 @@ impl Introspectable for AssetGraphContentSource { let root_assets = this.root_assets.await?; let root_asset_children = root_assets .iter() - .map(|&asset| (key, IntrospectableAsset::new(Vc::upcast(asset)))); + .map(|&asset| (key, IntrospectableOutputAsset::new(Vc::upcast(asset)))); let expanded_assets = self.all_assets_map().await?; let expanded_asset_children = expanded_assets .values() .filter(|a| !root_assets.contains(*a)) - .map(|asset| (inner_key, IntrospectableAsset::new(Vc::upcast(*asset)))); + .map(|asset| { + ( + inner_key, + IntrospectableOutputAsset::new(Vc::upcast(*asset)), + ) + }); Ok(Vc::cell( root_asset_children @@ -333,7 +338,7 @@ impl Introspectable for FullyExpaned { expand(&*source.root_assets.await?, &*source.root_path.await?, None).await?; let children = expanded_assets .iter() - .map(|(_k, &v)| (key, IntrospectableAsset::new(Vc::upcast(v)))) + .map(|(_k, &v)| (key, IntrospectableOutputAsset::new(v))) .collect(); Ok(Vc::cell(children)) diff --git a/crates/turbopack-dev-server/src/source/static_assets.rs b/crates/turbopack-dev-server/src/source/static_assets.rs index 2ccc7d1f852dc..0e938d7751d23 100644 --- a/crates/turbopack-dev-server/src/source/static_assets.rs +++ b/crates/turbopack-dev-server/src/source/static_assets.rs @@ -4,7 +4,7 @@ use turbo_tasks_fs::{DirectoryContent, DirectoryEntry, FileSystemPath}; use turbopack_core::{ asset::Asset, file_source::FileSource, - introspect::{asset::IntrospectableAsset, Introspectable, IntrospectableChildren}, + introspect::{source::IntrospectableSource, Introspectable, IntrospectableChildren}, version::VersionedContentExt, }; @@ -121,7 +121,7 @@ impl Introspectable for StaticAssetsContentSource { .map(|(name, entry)| { let child = match entry { DirectoryEntry::File(path) | DirectoryEntry::Symlink(path) => { - IntrospectableAsset::new(Vc::upcast(FileSource::new(*path))) + IntrospectableSource::new(Vc::upcast(FileSource::new(*path))) } DirectoryEntry::Directory(path) => { Vc::upcast(StaticAssetsContentSource::with_prefix( diff --git a/crates/turbopack-dev/src/ecmascript/runtime.rs b/crates/turbopack-dev/src/ecmascript/runtime.rs index 0e0fc0b1be565..3f0265fc0d02f 100644 --- a/crates/turbopack-dev/src/ecmascript/runtime.rs +++ b/crates/turbopack-dev/src/ecmascript/runtime.rs @@ -4,7 +4,6 @@ use turbopack_core::{ asset::Asset, chunk::{ChunkGroup, ChunkListReference, ChunkingContext}, ident::AssetIdent, - reference::AssetReferences, }; use turbopack_ecmascript::chunk::{ EcmascriptChunk, EcmascriptChunkPlaceables, EcmascriptChunkRuntime, diff --git a/crates/turbopack-dev/src/react_refresh.rs b/crates/turbopack-dev/src/react_refresh.rs index a2f7f798a1e4d..c2ad9092d8a8a 100644 --- a/crates/turbopack-dev/src/react_refresh.rs +++ b/crates/turbopack-dev/src/react_refresh.rs @@ -49,7 +49,8 @@ pub async fn assert_can_resolve_react_refresh( let resolve_options = apply_cjs_specific_options(turbopack::resolve_options(path, resolve_options_context)); for request in [react_refresh_request_in_next(), react_refresh_request()] { - let result = turbopack_core::resolve::resolve(path, request, resolve_options).first_asset(); + let result = + turbopack_core::resolve::resolve(path, request, resolve_options).first_source(); if result.await?.is_some() { return Ok(ResolveReactRefreshResult::Found(request).cell()); diff --git a/crates/turbopack-ecmascript/src/chunk/content.rs b/crates/turbopack-ecmascript/src/chunk/content.rs index c713d6d50c864..f648fd4f664f2 100644 --- a/crates/turbopack-ecmascript/src/chunk/content.rs +++ b/crates/turbopack-ecmascript/src/chunk/content.rs @@ -6,7 +6,7 @@ use turbopack_core::{ availability_info::AvailabilityInfo, chunk_content, chunk_content_split, Chunk, ChunkContentResult, }, - reference::AssetReference, + reference::ModuleReference, }; use super::{ @@ -19,7 +19,7 @@ use super::{ pub struct EcmascriptChunkContent { pub chunk_items: Vec>>, pub chunks: Vec>>, - pub external_asset_references: Vec>>, + pub external_module_references: Vec>>, pub availability_info: AvailabilityInfo, } @@ -28,7 +28,7 @@ impl From>>> for EcmascriptCh EcmascriptChunkContent { chunk_items: from.chunk_items, chunks: from.chunks, - external_asset_references: from.external_asset_references, + external_module_references: from.external_module_references, availability_info: from.availability_info, } } @@ -81,24 +81,24 @@ async fn ecmascript_chunk_content_internal( let mut all_chunk_items = IndexSet::>>::new(); let mut all_chunks = IndexSet::>>::new(); - let mut all_external_asset_references = IndexSet::>>::new(); + let mut all_external_module_references = IndexSet::>>::new(); for content in contents { let EcmascriptChunkContent { chunk_items, chunks, - external_asset_references, + external_module_references, availability_info: _, } = &*content.await?; all_chunk_items.extend(chunk_items.iter().copied()); all_chunks.extend(chunks.iter().copied()); - all_external_asset_references.extend(external_asset_references.iter().copied()); + all_external_module_references.extend(external_module_references.iter().copied()); } Ok(EcmascriptChunkContent { chunk_items: all_chunk_items.into_iter().collect(), chunks: all_chunks.into_iter().collect(), - external_asset_references: all_external_asset_references.into_iter().collect(), + external_module_references: all_external_module_references.into_iter().collect(), availability_info: availability_info.into_value(), } .cell()) diff --git a/crates/turbopack-ecmascript/src/chunk/esm_scope.rs b/crates/turbopack-ecmascript/src/chunk/esm_scope.rs index 47b40298d7eae..59b0e52e1c48c 100644 --- a/crates/turbopack-ecmascript/src/chunk/esm_scope.rs +++ b/crates/turbopack-ecmascript/src/chunk/esm_scope.rs @@ -4,7 +4,7 @@ use anyhow::{Context, Result}; use petgraph::{algo::tarjan_scc, prelude::DiGraphMap}; use turbo_tasks::{TryFlatJoinIterExt, Value, Vc}; use turbopack_core::{ - chunk::{availability_info::AvailabilityInfo, available_assets::chunkable_assets_set}, + chunk::{availability_info::AvailabilityInfo, available_modules::chunkable_modules_set}, module::{Module, ModulesSet}, }; @@ -36,7 +36,7 @@ impl EsmScope { #[turbo_tasks::function] pub(crate) async fn new(availability_info: Value) -> Result> { let assets = if let Some(root) = availability_info.current_availability_root() { - chunkable_assets_set(root) + chunkable_modules_set(root) } else { ModulesSet::empty() }; diff --git a/crates/turbopack-ecmascript/src/chunk/item.rs b/crates/turbopack-ecmascript/src/chunk/item.rs index a6ade5f7f6378..fae6d01065f3c 100644 --- a/crates/turbopack-ecmascript/src/chunk/item.rs +++ b/crates/turbopack-ecmascript/src/chunk/item.rs @@ -6,7 +6,7 @@ use turbo_tasks::{trace::TraceRawVcs, Upcast, Value, ValueToString, Vc}; use turbo_tasks_fs::rope::Rope; use turbopack_core::{ chunk::{ - availability_info::AvailabilityInfo, available_assets::AvailableAssets, ChunkItem, + availability_info::AvailabilityInfo, available_modules::AvailableAssets, ChunkItem, ChunkableModule, ChunkingContext, FromChunkableModule, ModuleId, }, code_builder::{Code, CodeBuilder}, @@ -273,14 +273,14 @@ impl FromChunkableModule for Box { AvailabilityInfo::Root { current_availability_root, } => AvailabilityInfo::Inner { - available_assets: AvailableAssets::new(vec![current_availability_root]), + available_modules: AvailableAssets::new(vec![current_availability_root]), current_availability_root: Vc::upcast(module), }, AvailabilityInfo::Inner { - available_assets, + available_modules, current_availability_root, } => AvailabilityInfo::Inner { - available_assets: available_assets.with_roots(vec![current_availability_root]), + available_modules: available_modules.with_roots(vec![current_availability_root]), current_availability_root: Vc::upcast(module), }, }; diff --git a/crates/turbopack-ecmascript/src/chunk/mod.rs b/crates/turbopack-ecmascript/src/chunk/mod.rs index dbd0dcfbe4827..06f292277e291 100644 --- a/crates/turbopack-ecmascript/src/chunk/mod.rs +++ b/crates/turbopack-ecmascript/src/chunk/mod.rs @@ -18,12 +18,13 @@ use turbopack_core::{ }, ident::AssetIdent, introspect::{ - asset::{children_from_output_assets, content_to_details, IntrospectableAsset}, + module::IntrospectableModule, + utils::{children_from_output_assets, content_to_details}, Introspectable, IntrospectableChildren, }, module::Module, output::OutputAssets, - reference::AssetReference, + reference::ModuleReference, }; use self::content::ecmascript_chunk_content; @@ -272,8 +273,8 @@ impl Chunk for EcmascriptChunk { let mut modifiers = vec![]; // Available assets are included - if let Some(available_assets) = this.availability_info.available_assets() { - modifiers.push(Vc::cell(available_assets.hash().await?.to_string())); + if let Some(available_modules) = this.availability_info.available_modules() { + modifiers.push(Vc::cell(available_modules.hash().await?.to_string())); } // Simplify when it's only a single main entry without extra info @@ -326,15 +327,13 @@ impl Chunk for EcmascriptChunk { .await?; let mut references = Vec::new(); let assets = content - .external_asset_references + .external_module_references .iter() - .map(|r| r.resolve_reference().primary_assets()) + .map(|r| r.resolve_reference().primary_output_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); - } + for &output_asset in assets.iter().flatten() { + references.push(output_asset); } Ok(Vc::cell(references)) @@ -456,7 +455,7 @@ impl Introspectable for EcmascriptChunk { for &entry in &*self.await?.main_entries.await? { children.insert(( entry_module_key(), - IntrospectableAsset::new(Vc::upcast(entry)), + IntrospectableModule::new(Vc::upcast(entry)), )); } Ok(Vc::cell(children)) diff --git a/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs b/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs index bc98b41e4ec68..295ffe1b3e9a6 100644 --- a/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs +++ b/crates/turbopack-ecmascript/src/chunk_group_files_asset.rs @@ -10,12 +10,14 @@ use turbopack_core::{ }, ident::AssetIdent, introspect::{ - asset::{content_to_details, IntrospectableAsset}, - Introspectable, IntrospectableChildren, + module::IntrospectableModule, utils::content_to_details, Introspectable, + IntrospectableChildren, }, module::Module, output::{OutputAsset, OutputAssets}, - reference::{AssetReference, AssetReferences, SingleAssetReference}, + reference::{ + ModuleReference, ModuleReferences, SingleModuleReference, SingleOutputAssetReference, + }, }; use crate::{ @@ -60,18 +62,17 @@ impl Module for ChunkGroupFilesAsset { } #[turbo_tasks::function] - async fn references(&self) -> Result> { - let mut references: Vec>> = vec![Vc::upcast( - SingleAssetReference::new(Vc::upcast(self.module), module_description()), + async fn references(&self) -> Result> { + let mut references: Vec>> = vec![Vc::upcast( + SingleModuleReference::new(Vc::upcast(self.module), module_description()), )]; if let Some(runtime_entries) = self.runtime_entries { references.extend(runtime_entries.await?.iter().map(|&entry| { - let reference: Vc> = Vc::upcast(SingleAssetReference::new( + Vc::upcast(SingleModuleReference::new( Vc::upcast(entry), runtime_entry_description(), - )); - reference + )) })); } @@ -207,7 +208,7 @@ impl ChunkItem for ChunkGroupFilesChunkItem { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let chunks = self.chunks(); Ok(Vc::cell( @@ -216,8 +217,8 @@ impl ChunkItem for ChunkGroupFilesChunkItem { .iter() .copied() .map(|chunk| { - SingleAssetReference::new( - Vc::upcast(chunk), + SingleOutputAssetReference::new( + chunk, chunk_group_chunk_reference_description(), ) }) @@ -249,7 +250,7 @@ impl Introspectable for ChunkGroupFilesAsset { let mut children = IndexSet::new(); children.insert(( Vc::cell("inner asset".to_string()), - IntrospectableAsset::new(Vc::upcast(self.await?.module)), + IntrospectableModule::new(Vc::upcast(self.await?.module)), )); Ok(Vc::cell(children)) } diff --git a/crates/turbopack-ecmascript/src/code_gen.rs b/crates/turbopack-ecmascript/src/code_gen.rs index b135840effdc0..7e9c747f14116 100644 --- a/crates/turbopack-ecmascript/src/code_gen.rs +++ b/crates/turbopack-ecmascript/src/code_gen.rs @@ -5,7 +5,7 @@ use turbopack_core::chunk::availability_info::AvailabilityInfo; use crate::chunk::EcmascriptChunkingContext; -/// impl of code generation inferred from a AssetReference. +/// impl of code generation inferred from a ModuleReference. /// This is rust only and can't be implemented by non-rust plugins. #[turbo_tasks::value( shared, diff --git a/crates/turbopack-ecmascript/src/lib.rs b/crates/turbopack-ecmascript/src/lib.rs index 302b46c0fb852..024953840ca5d 100644 --- a/crates/turbopack-ecmascript/src/lib.rs +++ b/crates/turbopack-ecmascript/src/lib.rs @@ -61,7 +61,7 @@ use turbopack_core::{ context::AssetContext, ident::AssetIdent, module::{Module, OptionModule}, - reference::AssetReferences, + reference::ModuleReferences, reference_type::InnerAssets, resolve::{origin::ResolveOrigin, parse::Request, ModulePart}, source::Source, @@ -120,7 +120,7 @@ fn modifier() -> Vc { #[derive(PartialEq, Eq, Clone, TraceRawVcs)] struct MemoizedSuccessfulAnalysis { operation: RawVc, - references: ReadRef, + references: ReadRef, exports: ReadRef, async_module: ReadRef, } @@ -388,7 +388,7 @@ impl Module for EcmascriptModuleAsset { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { Ok(self.failsafe_analyze().await?.references) } } @@ -484,7 +484,7 @@ impl ChunkItem for ModuleChunkItem { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.module.references() } } diff --git a/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs b/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs index 0e929bd23fa5f..0a6d91e1e1e8b 100644 --- a/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs +++ b/crates/turbopack-ecmascript/src/manifest/chunk_asset.rs @@ -6,7 +6,7 @@ use turbopack_core::{ ident::AssetIdent, module::Module, output::OutputAssets, - reference::{AssetReferences, SingleAssetReference}, + reference::{ModuleReferences, SingleOutputAssetReference}, }; use super::chunk_item::ManifestChunkItem; @@ -90,7 +90,7 @@ impl Module for ManifestChunkAsset { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let chunks = self.chunks(); Ok(Vc::cell( @@ -99,8 +99,8 @@ impl Module for ManifestChunkAsset { .iter() .copied() .map(|chunk| { - Vc::upcast(SingleAssetReference::new( - Vc::upcast(chunk), + Vc::upcast(SingleOutputAssetReference::new( + chunk, manifest_chunk_reference_description(), )) }) diff --git a/crates/turbopack-ecmascript/src/manifest/chunk_item.rs b/crates/turbopack-ecmascript/src/manifest/chunk_item.rs index 90e5999aca71f..0ab4146c333b9 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, SingleAssetReference}, + reference::{ModuleReferences, SingleOutputAssetReference}, }; use super::chunk_asset::ManifestChunkAsset; @@ -77,7 +77,7 @@ impl ChunkItem for ManifestChunkItem { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let mut references = this.manifest.references().await?.clone_value(); @@ -85,7 +85,7 @@ impl ChunkItem for ManifestChunkItem { for chunk_data in &*self.chunks_data().await? { references.extend(chunk_data.references().await?.iter().map(|&output_asset| { - Vc::upcast(SingleAssetReference::new(Vc::upcast(output_asset), key)) + Vc::upcast(SingleOutputAssetReference::new(output_asset, key)) })); } diff --git a/crates/turbopack-ecmascript/src/manifest/loader_item.rs b/crates/turbopack-ecmascript/src/manifest/loader_item.rs index b3703be8bf755..3f3338f9876a6 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::{AssetReference, AssetReferences, SingleAssetReference}, + reference::{ModuleReference, ModuleReferences, SingleOutputAssetReference}, }; use super::chunk_asset::ManifestChunkAsset; @@ -78,17 +78,17 @@ impl ChunkItem for ManifestLoaderItem { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { let this = self.await?; let chunks = this.manifest.manifest_chunks(); - let mut references: Vec>> = chunks + let mut references: Vec>> = chunks .await? .iter() .map(|&chunk| { - Vc::upcast(SingleAssetReference::new( - Vc::upcast(chunk), + Vc::upcast(SingleOutputAssetReference::new( + chunk, manifest_loader_chunk_reference_description(), )) }) @@ -96,8 +96,8 @@ impl ChunkItem for ManifestLoaderItem { for chunk_data in &*self.chunks_data().await? { references.extend(chunk_data.references().await?.iter().map(|&output_asset| { - Vc::upcast(SingleAssetReference::new( - Vc::upcast(output_asset), + Vc::upcast(SingleOutputAssetReference::new( + output_asset, chunk_data_reference_description(), )) })); diff --git a/crates/turbopack-ecmascript/src/references/amd.rs b/crates/turbopack-ecmascript/src/references/amd.rs index 93b213929aa0f..d26f7871444f2 100644 --- a/crates/turbopack-ecmascript/src/references/amd.rs +++ b/crates/turbopack-ecmascript/src/references/amd.rs @@ -16,8 +16,8 @@ use turbo_tasks::{ use turbopack_core::{ chunk::ChunkableModuleReference, issue::{IssueSource, OptionIssueSource}, - reference::AssetReference, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + reference::ModuleReference, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use super::pattern_mapping::{PatternMapping, ResolveType::Cjs}; @@ -57,9 +57,9 @@ impl AmdDefineAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for AmdDefineAssetReference { +impl ModuleReference for AmdDefineAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { cjs_resolve( self.origin, self.request, diff --git a/crates/turbopack-ecmascript/src/references/cjs.rs b/crates/turbopack-ecmascript/src/references/cjs.rs index 013c89fad0ea4..3476e3719566e 100644 --- a/crates/turbopack-ecmascript/src/references/cjs.rs +++ b/crates/turbopack-ecmascript/src/references/cjs.rs @@ -7,8 +7,8 @@ use turbo_tasks::{Value, ValueToString, Vc}; use turbopack_core::{ chunk::ChunkableModuleReference, issue::{IssueSource, OptionIssueSource}, - reference::AssetReference, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + reference::ModuleReference, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use super::pattern_mapping::{PatternMapping, ResolveType::Cjs}; @@ -48,9 +48,9 @@ impl CjsAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for CjsAssetReference { +impl ModuleReference for CjsAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { cjs_resolve( self.origin, self.request, @@ -105,9 +105,9 @@ impl CjsRequireAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for CjsRequireAssetReference { +impl ModuleReference for CjsRequireAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { cjs_resolve( self.origin, self.request, @@ -229,9 +229,9 @@ impl CjsRequireResolveAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for CjsRequireResolveAssetReference { +impl ModuleReference for CjsRequireResolveAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { cjs_resolve( self.origin, self.request, diff --git a/crates/turbopack-ecmascript/src/references/esm/base.rs b/crates/turbopack-ecmascript/src/references/esm/base.rs index ccf30d91595ce..62c07ab4914c0 100644 --- a/crates/turbopack-ecmascript/src/references/esm/base.rs +++ b/crates/turbopack-ecmascript/src/references/esm/base.rs @@ -13,12 +13,12 @@ use turbopack_core::{ }, issue::{IssueSeverity, OptionIssueSource}, module::Module, - reference::AssetReference, + reference::ModuleReference, reference_type::EcmaScriptModulesReferenceSubType, resolve::{ origin::{ResolveOrigin, ResolveOriginExt}, parse::Request, - ModulePart, PrimaryResolveResult, ResolveResult, + ModulePart, ModuleResolveResult, ModuleResolveResultItem, }, }; @@ -64,26 +64,26 @@ impl ReferencedAsset { impl ReferencedAsset { #[turbo_tasks::function] pub async fn from_resolve_result( - resolve_result: Vc, + resolve_result: Vc, request: Vc, ) -> Result> { for result in resolve_result.await?.primary.iter() { match result { - PrimaryResolveResult::OriginalReferenceExternal => { + ModuleResolveResultItem::OriginalReferenceExternal => { if let Some(request) = request.await?.request() { return Ok(ReferencedAsset::OriginalReferenceTypeExternal(request).cell()); } else { return Ok(ReferencedAsset::cell(ReferencedAsset::None)); } } - PrimaryResolveResult::OriginalReferenceTypeExternal(request) => { + ModuleResolveResultItem::OriginalReferenceTypeExternal(request) => { return Ok( ReferencedAsset::OriginalReferenceTypeExternal(request.clone()).cell(), ); } - PrimaryResolveResult::Asset(asset) => { + &ModuleResolveResultItem::Module(module) => { if let Some(placeable) = - Vc::try_resolve_sidecast::>(*asset) + Vc::try_resolve_downcast::>(module) .await? { return Ok(ReferencedAsset::cell(ReferencedAsset::Some(placeable))); @@ -179,9 +179,9 @@ impl EsmAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for EsmAssetReference { +impl ModuleReference for EsmAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { let ty = Value::new(match &self.export_name { Some(part) => EcmaScriptModulesReferenceSubType::ImportPart(*part), None => EcmaScriptModulesReferenceSubType::Undefined, diff --git a/crates/turbopack-ecmascript/src/references/esm/dynamic.rs b/crates/turbopack-ecmascript/src/references/esm/dynamic.rs index 05bfeafa9ae24..bc0df11abc3eb 100644 --- a/crates/turbopack-ecmascript/src/references/esm/dynamic.rs +++ b/crates/turbopack-ecmascript/src/references/esm/dynamic.rs @@ -10,9 +10,9 @@ use turbopack_core::{ ChunkingTypeOption, }, issue::{IssueSource, OptionIssueSource}, - reference::AssetReference, + reference::ModuleReference, reference_type::EcmaScriptModulesReferenceSubType, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use super::super::pattern_mapping::{PatternMapping, ResolveType::EsmAsync}; @@ -55,9 +55,9 @@ impl EsmAsyncAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for EsmAsyncAssetReference { +impl ModuleReference for EsmAsyncAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { esm_resolve( self.origin, self.request, diff --git a/crates/turbopack-ecmascript/src/references/esm/module_id.rs b/crates/turbopack-ecmascript/src/references/esm/module_id.rs index 1c06a566907d0..5ee8edc7e5136 100644 --- a/crates/turbopack-ecmascript/src/references/esm/module_id.rs +++ b/crates/turbopack-ecmascript/src/references/esm/module_id.rs @@ -3,8 +3,8 @@ use swc_core::{ecma::ast::Expr, quote}; use turbo_tasks::{ValueToString, Vc}; use turbopack_core::{ chunk::{ChunkableModuleReference, ChunkingTypeOption, ModuleId}, - reference::AssetReference, - resolve::ResolveResult, + reference::ModuleReference, + resolve::ModuleResolveResult, }; use super::{base::ReferencedAsset, EsmAssetReference}; @@ -31,9 +31,9 @@ impl EsmModuleIdAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for EsmModuleIdAssetReference { +impl ModuleReference for EsmModuleIdAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { self.inner.resolve_reference() } } diff --git a/crates/turbopack-ecmascript/src/references/esm/url.rs b/crates/turbopack-ecmascript/src/references/esm/url.rs index 4b150a7f5865b..4e7996e8a34c5 100644 --- a/crates/turbopack-ecmascript/src/references/esm/url.rs +++ b/crates/turbopack-ecmascript/src/references/esm/url.rs @@ -8,9 +8,9 @@ use turbopack_core::{ chunk::{ChunkableModuleReference, ChunkingType, ChunkingTypeOption}, environment::Rendering, issue::{code_gen::CodeGenerationIssue, IssueExt, IssueSeverity, IssueSource}, - reference::AssetReference, + reference::ModuleReference, reference_type::UrlReferenceSubType, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, }; use super::base::ReferencedAsset; @@ -71,9 +71,9 @@ impl UrlAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for UrlAssetReference { +impl ModuleReference for UrlAssetReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Vc { + async fn resolve_reference(&self) -> Vc { url_resolve( self.origin, self.request, diff --git a/crates/turbopack-ecmascript/src/references/mod.rs b/crates/turbopack-ecmascript/src/references/mod.rs index c1ca498760272..984bdf57d105a 100644 --- a/crates/turbopack-ecmascript/src/references/mod.rs +++ b/crates/turbopack-ecmascript/src/references/mod.rs @@ -52,7 +52,7 @@ use turbopack_core::{ error::PrettyPrintError, issue::{analyze::AnalyzeIssue, IssueExt, IssueSeverity, IssueSource, OptionIssueSource}, module::Module, - reference::{AssetReference, AssetReferences, SourceMapReference}, + reference::{ModuleReference, ModuleReferences, SourceMapReference}, reference_type::{CommonJsReferenceSubType, ReferenceType}, resolve::{ find_context_file, @@ -60,9 +60,9 @@ use turbopack_core::{ package_json, parse::Request, pattern::Pattern, - resolve, FindContextFileResult, ModulePart, PrimaryResolveResult, + resolve, FindContextFileResult, ModulePart, }, - source::{asset_to_source, Source}, + source::Source, }; use turbopack_swc_utils::emitter::IssueEmitter; use unreachable::Unreachable; @@ -129,7 +129,7 @@ use crate::{ #[turbo_tasks::value(shared)] pub struct AnalyzeEcmascriptModuleResult { - pub references: Vc, + pub references: Vc, pub code_generation: Vc, pub exports: Vc, pub async_module: Vc, @@ -166,7 +166,7 @@ impl AnalyzeEcmascriptModuleResult { /// A temporary analysis result builder to pass around, to be turned into an /// `Vc` eventually. pub(crate) struct AnalyzeEcmascriptModuleResultBuilder { - references: IndexSet>>, + references: IndexSet>>, code_gens: Vec, exports: EcmascriptExports, async_module: Vc, @@ -187,7 +187,7 @@ impl AnalyzeEcmascriptModuleResultBuilder { /// Adds an asset reference to the analysis result. pub fn add_reference(&mut self, reference: Vc) where - R: Upcast>, + R: Upcast>, { self.references.insert(Vc::upcast(reference)); } @@ -489,7 +489,7 @@ pub(crate) async fn analyze_ecmascript_module( set_handler_and_globals(&handler, globals, || { // TODO migrate to effects let mut visitor = - AssetReferencesVisitor::new(eval_context, &import_references, &mut analysis); + ModuleReferencesVisitor::new(eval_context, &import_references, &mut analysis); for (i, reexport) in eval_context.imports.reexports() { let import_ref = import_references[i]; @@ -2109,28 +2109,14 @@ async fn require_resolve_visitor( request, OptionIssueSource::none(), try_to_severity(in_try), - ) - .await?; + ); let mut values = resolved - .primary + .primary_modules() + .await? .iter() - .map(|result| async move { - Ok(if let &PrimaryResolveResult::Asset(asset) = result { - if let Some(module) = Vc::try_resolve_downcast::>(asset).await? - { - Some(require_resolve(module.ident().path()).await?) - } else { - None - } - } else { - None - }) - }) + .map(|&module| async move { require_resolve(module.ident().path()).await }) .try_join() - .await? - .into_iter() - .flatten() - .collect::>(); + .await?; match values.len() { 0 => JsValue::unknown( @@ -2254,7 +2240,7 @@ impl StaticAnalyser { } } -struct AssetReferencesVisitor<'a> { +struct ModuleReferencesVisitor<'a> { eval_context: &'a EvalContext, old_analyser: StaticAnalyser, import_references: &'a [Vc], @@ -2266,7 +2252,7 @@ struct AssetReferencesVisitor<'a> { webpack_chunks: Vec, } -impl<'a> AssetReferencesVisitor<'a> { +impl<'a> ModuleReferencesVisitor<'a> { fn new( eval_context: &'a EvalContext, import_references: &'a [Vc], @@ -2347,7 +2333,7 @@ fn for_each_ident_in_pat(pat: &Pat, f: &mut impl FnMut(String)) { } } -impl<'a> VisitAstPath for AssetReferencesVisitor<'a> { +impl<'a> VisitAstPath for ModuleReferencesVisitor<'a> { fn visit_export_all<'ast: 'r, 'r>( &mut self, export: &'ast ExportAll, @@ -2599,8 +2585,8 @@ async fn resolve_as_webpack_runtime( options, ); - if let Some(source) = *resolved.first_asset().await? { - Ok(webpack_runtime(asset_to_source(source), transforms)) + if let Some(source) = *resolved.first_source().await? { + Ok(webpack_runtime(source, transforms)) } else { Ok(WebpackRuntime::None.into()) } diff --git a/crates/turbopack-ecmascript/src/references/node.rs b/crates/turbopack-ecmascript/src/references/node.rs index 2124bb8640940..19b231138c645 100644 --- a/crates/turbopack-ecmascript/src/references/node.rs +++ b/crates/turbopack-ecmascript/src/references/node.rs @@ -7,10 +7,10 @@ use turbo_tasks_fs::{ DirectoryContent, DirectoryEntry, FileSystem, FileSystemEntryType, FileSystemPath, }; use turbopack_core::{ - asset::Asset, file_source::FileSource, - reference::AssetReference, - resolve::{pattern::Pattern, ResolveResult}, + raw_module::RawModule, + reference::ModuleReference, + resolve::{pattern::Pattern, ModuleResolveResult}, source::Source, }; @@ -29,10 +29,13 @@ impl PackageJsonReference { } #[turbo_tasks::value_impl] -impl AssetReference for PackageJsonReference { +impl ModuleReference for PackageJsonReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(FileSource::new(self.package_json))).into() + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(Vc::upcast(RawModule::new(Vc::upcast(FileSource::new( + self.package_json, + ))))) + .cell() } } @@ -63,13 +66,13 @@ impl DirAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for DirAssetReference { +impl ModuleReference for DirAssetReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { + async fn resolve_reference(&self) -> Result> { let context_path = self.source.ident().path().await?; // ignore path.join in `node-gyp`, it will includes too many files if context_path.path.contains("node_modules/node-gyp") { - return Ok(ResolveResult::unresolveable().into()); + return Ok(ModuleResolveResult::unresolveable().cell()); } let context = self.source.ident().path().parent(); let pat = self.path.await?; @@ -90,7 +93,13 @@ impl AssetReference for DirAssetReference { } _ => {} } - Ok(ResolveResult::assets_with_references(result.into_iter().collect(), vec![]).into()) + Ok(ModuleResolveResult::modules( + result + .into_iter() + .map(|source| Vc::upcast(RawModule::new(source))) + .collect(), + ) + .cell()) } } @@ -105,12 +114,12 @@ impl ValueToString for DirAssetReference { } } -type AssetSet = IndexSet>>; +type SourceSet = IndexSet>>; async fn extend_with_constant_pattern( pattern: &str, fs: Vc>, - result: &mut AssetSet, + result: &mut SourceSet, ) -> Result<()> { let dest_file_path = fs .root() @@ -143,7 +152,7 @@ async fn extend_with_constant_pattern( Ok(()) } -async fn read_dir(p: Vc) -> Result { +async fn read_dir(p: Vc) -> Result { let mut result = IndexSet::new(); let dir_entries = p.read_dir().await?; if let DirectoryContent::Entries(entries) = &*dir_entries { @@ -165,6 +174,8 @@ async fn read_dir(p: Vc) -> Result { Ok(result) } -fn read_dir_boxed(p: Vc) -> Pin> + Send>> { +fn read_dir_boxed( + p: Vc, +) -> Pin> + Send>> { Box::pin(read_dir(p)) } diff --git a/crates/turbopack-ecmascript/src/references/pattern_mapping.rs b/crates/turbopack-ecmascript/src/references/pattern_mapping.rs index 225e0c8a067e7..a5012ca49aa38 100644 --- a/crates/turbopack-ecmascript/src/references/pattern_mapping.rs +++ b/crates/turbopack-ecmascript/src/references/pattern_mapping.rs @@ -11,7 +11,9 @@ use turbopack_core::{ ModuleId, }, issue::{code_gen::CodeGenerationIssue, IssueExt, IssueSeverity}, - resolve::{origin::ResolveOrigin, parse::Request, PrimaryResolveResult, ResolveResult}, + resolve::{ + origin::ResolveOrigin, parse::Request, ModuleResolveResult, ModuleResolveResultItem, + }, }; use super::util::{request_to_string, throw_module_not_found_expr}; @@ -125,25 +127,25 @@ impl PatternMapping { request: Vc, origin: Vc>, context: Vc>, - resolve_result: Vc, + resolve_result: Vc, resolve_type: Value, ) -> Result> { let result = resolve_result.await?; - let asset = match result.primary.first() { + let module = match result.primary.first() { None => { return Ok(PatternMapping::Unresolveable( request_to_string(request).await?.to_string(), ) .cell()) } - Some(PrimaryResolveResult::Asset(asset)) => *asset, - Some(PrimaryResolveResult::OriginalReferenceExternal) => { + Some(ModuleResolveResultItem::Module(module)) => *module, + Some(ModuleResolveResultItem::OriginalReferenceExternal) => { return Ok(PatternMapping::OriginalReferenceExternal.cell()) } - Some(PrimaryResolveResult::OriginalReferenceTypeExternal(s)) => { + Some(ModuleResolveResultItem::OriginalReferenceTypeExternal(s)) => { return Ok(PatternMapping::OriginalReferenceTypeExternal(s.clone()).cell()) } - Some(PrimaryResolveResult::Ignore) => return Ok(PatternMapping::Ignored.cell()), + Some(ModuleResolveResultItem::Ignore) => return Ok(PatternMapping::Ignored.cell()), _ => { // TODO implement mapping CodeGenerationIssue { @@ -164,15 +166,16 @@ impl PatternMapping { } }; - if let Some(chunkable) = Vc::try_resolve_sidecast::>(asset).await? + if let Some(chunkable) = + Vc::try_resolve_downcast::>(module).await? { if let ResolveType::EsmAsync(availability_info) = *resolve_type { - let available = if let Some(available_assets) = availability_info.available_assets() - { - *available_assets.includes(Vc::upcast(chunkable)).await? - } else { - false - }; + let available = + if let Some(available_modules) = availability_info.available_modules() { + *available_modules.includes(Vc::upcast(chunkable)).await? + } else { + false + }; if !available { if let Some(loader) = >::from_async_asset( context, diff --git a/crates/turbopack-ecmascript/src/references/raw.rs b/crates/turbopack-ecmascript/src/references/raw.rs index 09b16a4c8f289..b781810340e5f 100644 --- a/crates/turbopack-ecmascript/src/references/raw.rs +++ b/crates/turbopack-ecmascript/src/references/raw.rs @@ -1,8 +1,8 @@ use anyhow::Result; use turbo_tasks::{ValueToString, Vc}; use turbopack_core::{ - reference::AssetReference, - resolve::{pattern::Pattern, resolve_raw, ResolveResult}, + reference::ModuleReference, + resolve::{pattern::Pattern, resolve_raw, ModuleResolveResult}, source::Source, }; @@ -22,12 +22,12 @@ impl FileSourceReference { } #[turbo_tasks::value_impl] -impl AssetReference for FileSourceReference { +impl ModuleReference for FileSourceReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { + fn resolve_reference(&self) -> Vc { let context = self.source.ident().path().parent(); - Ok(resolve_raw(context, self.path, false)) + resolve_raw(context, self.path, false).as_raw_module_result() } } diff --git a/crates/turbopack-ecmascript/src/references/require_context.rs b/crates/turbopack-ecmascript/src/references/require_context.rs index 6586800bc8639..04bcb9d93c286 100644 --- a/crates/turbopack-ecmascript/src/references/require_context.rs +++ b/crates/turbopack-ecmascript/src/references/require_context.rs @@ -24,8 +24,8 @@ use turbopack_core::{ ident::AssetIdent, issue::{IssueSeverity, OptionIssueSource}, module::Module, - reference::{AssetReference, AssetReferences}, - resolve::{origin::ResolveOrigin, parse::Request, ResolveResult}, + reference::{ModuleReference, ModuleReferences}, + resolve::{origin::ResolveOrigin, parse::Request, ModuleResolveResult}, source::Source, }; @@ -150,7 +150,7 @@ impl FlatDirList { pub struct RequireContextMapEntry { pub origin_relative: String, pub request: Vc, - pub result: Vc, + pub result: Vc, } /// The resolved context map for a `require.context(..)` call. @@ -253,10 +253,10 @@ impl RequireContextAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for RequireContextAssetReference { +impl ModuleReference for RequireContextAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(self.inner)).cell() + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(Vc::upcast(self.inner)).cell() } } @@ -302,18 +302,18 @@ impl CodeGenerateable for RequireContextAssetReference { } #[turbo_tasks::value(transparent)] -pub struct ResolvedAssetReference(Vc); +pub struct ResolvedModuleReference(Vc); #[turbo_tasks::value_impl] -impl AssetReference for ResolvedAssetReference { +impl ModuleReference for ResolvedModuleReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { self.0 } } #[turbo_tasks::value_impl] -impl ValueToString for ResolvedAssetReference { +impl ValueToString for ResolvedModuleReference { #[turbo_tasks::function] async fn to_string(&self) -> Result> { Ok(Vc::cell("resolved reference".to_string())) @@ -321,7 +321,7 @@ impl ValueToString for ResolvedAssetReference { } #[turbo_tasks::value_impl] -impl ChunkableModuleReference for ResolvedAssetReference {} +impl ChunkableModuleReference for ResolvedModuleReference {} #[turbo_tasks::value] pub struct RequireContextAsset { @@ -353,12 +353,12 @@ impl Module for RequireContextAsset { } #[turbo_tasks::function] - async fn references(&self) -> Result> { + async fn references(&self) -> Result> { let map = &*self.map.await?; Ok(Vc::cell( map.iter() - .map(|(_, entry)| Vc::upcast(Vc::::cell(entry.result))) + .map(|(_, entry)| Vc::upcast(Vc::::cell(entry.result))) .collect(), )) } @@ -514,7 +514,7 @@ impl ChunkItem for RequireContextChunkItem { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.inner.references() } } diff --git a/crates/turbopack-ecmascript/src/references/typescript.rs b/crates/turbopack-ecmascript/src/references/typescript.rs index 76adb127e492b..bd54ad450cf07 100644 --- a/crates/turbopack-ecmascript/src/references/typescript.rs +++ b/crates/turbopack-ecmascript/src/references/typescript.rs @@ -4,9 +4,9 @@ use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ context::AssetContext, file_source::FileSource, - reference::AssetReference, + reference::ModuleReference, reference_type::{ReferenceType, TypeScriptReferenceSubType}, - resolve::{origin::ResolveOrigin, parse::Request, pattern::QueryMap, ResolveResult}, + resolve::{origin::ResolveOrigin, parse::Request, pattern::QueryMap, ModuleResolveResult}, }; use crate::typescript::{resolve::type_resolve, TsConfigModuleAsset}; @@ -27,10 +27,10 @@ impl TsConfigReference { } #[turbo_tasks::value_impl] -impl AssetReference for TsConfigReference { +impl ModuleReference for TsConfigReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(TsConfigModuleAsset::new( + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(Vc::upcast(TsConfigModuleAsset::new( self.origin, Vc::upcast(FileSource::new(self.tsconfig)), ))) @@ -65,9 +65,9 @@ impl TsReferencePathAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for TsReferencePathAssetReference { +impl ModuleReference for TsReferencePathAssetReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { + async fn resolve_reference(&self) -> Result> { Ok( if let Some(path) = &*self .origin @@ -76,15 +76,15 @@ impl AssetReference for TsReferencePathAssetReference { .try_join(self.path.clone()) .await? { - ResolveResult::asset(Vc::upcast(self.origin.context().process( + ModuleResolveResult::module(Vc::upcast(self.origin.context().process( Vc::upcast(FileSource::new(*path)), Value::new(ReferenceType::TypeScript( TypeScriptReferenceSubType::Undefined, )), ))) - .into() + .cell() } else { - ResolveResult::unresolveable().into() + ModuleResolveResult::unresolveable().cell() }, ) } @@ -117,9 +117,9 @@ impl TsReferenceTypeAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for TsReferenceTypeAssetReference { +impl ModuleReference for TsReferenceTypeAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { type_resolve( self.origin, Request::module( diff --git a/crates/turbopack-ecmascript/src/resolve/mod.rs b/crates/turbopack-ecmascript/src/resolve/mod.rs index e997c5c82bc4e..dd830e5027b81 100644 --- a/crates/turbopack-ecmascript/src/resolve/mod.rs +++ b/crates/turbopack-ecmascript/src/resolve/mod.rs @@ -17,7 +17,7 @@ use turbopack_core::{ }, origin::{ResolveOrigin, ResolveOriginExt}, parse::Request, - resolve, ResolveResult, + resolve, ModuleResolveResult, }, }; /// Retrieves the [ResolutionConditions] of both the "into" package (allowing a @@ -66,7 +66,7 @@ pub async fn esm_resolve( ty: Value, issue_source: Vc, issue_severity: Vc, -) -> Result> { +) -> Result> { let ty = Value::new(ReferenceType::EcmaScriptModules(ty.into_value())); let options = apply_esm_specific_options(origin.resolve_options(ty.clone())); specific_resolve(origin, request, options, ty, issue_source, issue_severity).await @@ -78,7 +78,7 @@ pub async fn cjs_resolve( request: Vc, issue_source: Vc, issue_severity: Vc, -) -> Result> { +) -> Result> { // TODO pass CommonJsReferenceSubType let ty = Value::new(ReferenceType::CommonJs(CommonJsReferenceSubType::Undefined)); let options = apply_cjs_specific_options(origin.resolve_options(ty.clone())); @@ -92,7 +92,7 @@ pub async fn url_resolve( ty: Value, issue_source: Vc, issue_severity: Vc, -) -> Result> { +) -> Result> { let ty = Value::new(ReferenceType::Url(ty.into_value())); let resolve_options = origin.resolve_options(ty.clone()); let rel_request = request.as_relative(); @@ -100,21 +100,21 @@ pub async fn url_resolve( let result = if *rel_result.is_unresolveable().await? && rel_request.resolve().await? != request { resolve(origin.origin_path().parent(), request, resolve_options) - .with_references(rel_result.await?.get_references().clone()) + .with_affecting_sources(rel_result.await?.get_affecting_sources().clone()) } else { rel_result }; - let _ = handle_resolve_error( + let result = origin.context().process_resolve_result(result, ty.clone()); + handle_resolve_error( result, - ty.clone(), + ty, origin.origin_path(), request, resolve_options, OptionIssueSource::some(issue_source), issue_severity, ) - .await?; - Ok(origin.context().process_resolve_result(result, ty)) + .await } async fn specific_resolve( @@ -124,7 +124,7 @@ async fn specific_resolve( reference_type: Value, issue_source: Vc, issue_severity: Vc, -) -> Result> { +) -> Result> { let result = origin.resolve_asset(request, options, reference_type.clone()); handle_resolve_error( diff --git a/crates/turbopack-ecmascript/src/resolve/node_native_binding.rs b/crates/turbopack-ecmascript/src/resolve/node_native_binding.rs index 58fcc03b664c3..167f123cd8f66 100644 --- a/crates/turbopack-ecmascript/src/resolve/node_native_binding.rs +++ b/crates/turbopack-ecmascript/src/resolve/node_native_binding.rs @@ -11,12 +11,14 @@ use turbo_tasks_fs::{ use turbopack_core::{ asset::{Asset, AssetContent}, file_source::FileSource, - module::{convert_asset_to_module, Module}, - reference::AssetReference, + module::Module, + raw_module::RawModule, + reference::ModuleReference, resolve::{ - pattern::Pattern, resolve_raw, AffectingResolvingAssetReference, PrimaryResolveResult, - ResolveResult, + pattern::Pattern, resolve_raw, AffectingResolvingAssetReference, ModuleResolveResult, + ResolveResultItem, }, + source::Source, target::{CompileTarget, Platform}, }; @@ -59,9 +61,9 @@ impl NodePreGypConfigReference { } #[turbo_tasks::value_impl] -impl AssetReference for NodePreGypConfigReference { +impl ModuleReference for NodePreGypConfigReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { resolve_node_pre_gyp_files(self.context, self.config_file_pattern, self.compile_target) } } @@ -84,7 +86,7 @@ pub async fn resolve_node_pre_gyp_files( context: Vc, config_file_pattern: Vc, compile_target: Vc, -) -> Result> { +) -> Result> { lazy_static! { static ref NAPI_VERSION_TEMPLATE: Regex = Regex::new(r"\{(napi_build_version|node_napi_label)\}") @@ -97,18 +99,17 @@ pub async fn resolve_node_pre_gyp_files( Regex::new(r"\{libc\}").expect("create node_libc regex failed"); } let config = resolve_raw(context, config_file_pattern, true) - .first_asset() + .first_source() .await?; let compile_target = compile_target.await?; if let Some(config_asset) = *config { - let config_asset = convert_asset_to_module(config_asset); if let AssetContent::File(file) = &*config_asset.content().await? { if let FileContent::Content(ref config_file) = &*file.await? { let config_file_path = config_asset.ident().path(); let config_file_dir = config_file_path.parent(); let node_pre_gyp_config: NodePreGypConfigJson = parse_json_rope_with_source_context(config_file.content())?; - let mut assets: IndexSet>> = IndexSet::new(); + let mut sources: IndexSet>> = IndexSet::new(); for version in node_pre_gyp_config.binary.napi_versions.iter() { let native_binding_path = NAPI_VERSION_TEMPLATE.replace( node_pre_gyp_config.binary.module_path.as_str(), @@ -145,10 +146,10 @@ pub async fn resolve_node_pre_gyp_files( if let &DirectoryEntry::File(dylib) | &DirectoryEntry::Symlink(dylib) = entry { - assets.insert(Vc::upcast(FileSource::new(dylib))); + sources.insert(Vc::upcast(FileSource::new(dylib))); } } - assets.insert(Vc::upcast(FileSource::new(resolved_file_vc))); + sources.insert(Vc::upcast(FileSource::new(resolved_file_vc))); } for entry in config_asset .ident() @@ -164,29 +165,32 @@ pub async fn resolve_node_pre_gyp_files( { match *entry { DirectoryEntry::File(dylib) => { - assets.insert(Vc::upcast(FileSource::new(dylib))); + sources.insert(Vc::upcast(FileSource::new(dylib))); } DirectoryEntry::Symlink(dylib) => { let realpath_with_links = dylib.realpath_with_links().await?; for symlink in realpath_with_links.symlinks.iter() { - assets.insert(Vc::upcast(FileSource::new(*symlink))); + sources.insert(Vc::upcast(FileSource::new(*symlink))); } - assets.insert(Vc::upcast(FileSource::new(dylib))); + sources.insert(Vc::upcast(FileSource::new(dylib))); } _ => {} } } - return Ok(ResolveResult::assets_with_references( - assets.into_iter().collect(), + return Ok(ModuleResolveResult::modules_with_references( + sources + .into_iter() + .map(|source| Vc::upcast(RawModule::new(source))) + .collect(), vec![Vc::upcast(AffectingResolvingAssetReference::new( - config_file_path, + Vc::upcast(FileSource::new(config_file_path)), ))], ) .into()); } }; } - Ok(ResolveResult::unresolveable().into()) + Ok(ModuleResolveResult::unresolveable().into()) } #[turbo_tasks::value] @@ -208,9 +212,9 @@ impl NodeGypBuildReference { } #[turbo_tasks::value_impl] -impl AssetReference for NodeGypBuildReference { +impl ModuleReference for NodeGypBuildReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { resolve_node_gyp_build_files(self.context, self.compile_target) } } @@ -231,22 +235,27 @@ impl ValueToString for NodeGypBuildReference { pub async fn resolve_node_gyp_build_files( context: Vc, compile_target: Vc, -) -> Result> { +) -> Result> { lazy_static! { static ref GYP_BUILD_TARGET_NAME: Regex = Regex::new(r#"['"]target_name['"]\s*:\s*(?:"(.*?)"|'(.*?)')"#) .expect("create napi_build_version regex failed"); } let binding_gyp_pat = Pattern::new(Pattern::Constant("binding.gyp".to_owned())); - let gyp_file = resolve_raw(context, binding_gyp_pat, true).await?; - if let [PrimaryResolveResult::Asset(binding_gyp)] = &gyp_file.primary[..] { - let mut merged_references = gyp_file.references.clone(); + let gyp_file = resolve_raw(context, binding_gyp_pat, true); + if let [binding_gyp] = &gyp_file.primary_sources().await?[..] { + let mut merged_references = gyp_file + .await? + .get_affecting_sources() + .iter() + .map(|&r| Vc::upcast(AffectingResolvingAssetReference::new(r))) + .collect::>(); if let AssetContent::File(file) = &*binding_gyp.content().await? { if let FileContent::Content(config_file) = &*file.await? { if let Some(captured) = GYP_BUILD_TARGET_NAME.captures(&config_file.content().to_str()?) { - let mut resolved: IndexSet>> = + let mut resolved: IndexSet>> = IndexSet::with_capacity(captured.len()); for found in captured.iter().skip(1).flatten() { let name = found.as_str(); @@ -257,16 +266,24 @@ pub async fn resolve_node_gyp_build_files( true, ) .await?; - if let [PrimaryResolveResult::Asset(asset)] = + if let &[ResolveResultItem::Source(source)] = &resolved_prebuilt_file.primary[..] { - resolved.insert(asset.resolve().await?); - merged_references.extend_from_slice(&resolved_prebuilt_file.references); + resolved.insert(source.resolve().await?); + merged_references.extend( + resolved_prebuilt_file + .affecting_sources + .iter() + .map(|&r| Vc::upcast(AffectingResolvingAssetReference::new(r))), + ); } } if !resolved.is_empty() { - return Ok(ResolveResult::assets_with_references( - resolved.into_iter().collect(), + return Ok(ModuleResolveResult::modules_with_references( + resolved + .into_iter() + .map(|source| Vc::upcast(RawModule::new(source))) + .collect(), merged_references, ) .into()); @@ -288,7 +305,8 @@ pub async fn resolve_node_gyp_build_files( ]) .into(), true, - )) + ) + .as_raw_module_result()) } #[turbo_tasks::value] @@ -307,9 +325,9 @@ impl NodeBindingsReference { } #[turbo_tasks::value_impl] -impl AssetReference for NodeBindingsReference { +impl ModuleReference for NodeBindingsReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { resolve_node_bindings_files(self.context, self.file_name.clone()) } } @@ -329,7 +347,7 @@ impl ValueToString for NodeBindingsReference { pub async fn resolve_node_bindings_files( context: Vc, file_name: String, -) -> Result> { +) -> Result> { lazy_static! { static ref BINDINGS_TRY: [&'static str; 5] = [ "build/bindings", @@ -346,7 +364,7 @@ pub async fn resolve_node_bindings_files( Pattern::Constant("package.json".to_owned()).into(), true, ) - .first_asset() + .first_source() .await?; if let Some(asset) = *resolved { if let AssetContent::File(file) = &*asset.content().await? { @@ -363,21 +381,21 @@ pub async fn resolve_node_bindings_files( } root_context = parent; } - let bindings_try: Vec>> = BINDINGS_TRY + let bindings_try: Vec>> = BINDINGS_TRY .iter() .map(|try_dir| { - Vc::upcast(FileSource::new( + Vc::upcast(RawModule::new(Vc::upcast(FileSource::new( root_context.join(format!("{}/{}", try_dir, &file_name)), - )) + )))) }) .collect(); - Ok(ResolveResult::assets_with_references( + Ok(ModuleResolveResult::modules_with_references( bindings_try, vec![Vc::upcast(FileSourceReference::new( Vc::upcast(FileSource::new(root_context)), Pattern::Concatenation(vec![Pattern::Dynamic, Pattern::Constant(file_name)]).into(), ))], ) - .into()) + .cell()) } diff --git a/crates/turbopack-ecmascript/src/tree_shake/asset.rs b/crates/turbopack-ecmascript/src/tree_shake/asset.rs index c35f75592c6ef..64f109397a2be 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/asset.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/asset.rs @@ -5,7 +5,7 @@ use turbopack_core::{ chunk::{availability_info::AvailabilityInfo, Chunk, ChunkableModule, ChunkingContext}, ident::AssetIdent, module::Module, - reference::{AssetReferences, SingleAssetReference}, + reference::{ModuleReferences, SingleModuleReference}, resolve::ModulePart, }; @@ -53,7 +53,7 @@ impl Module for EcmascriptModulePartAsset { } #[turbo_tasks::function] - async fn references(&self) -> Result> { + async fn references(&self) -> Result> { let split_data = split_module(self.full_module).await?; let deps = match &*split_data { @@ -75,7 +75,7 @@ impl Module for EcmascriptModulePartAsset { let mut assets = deps .iter() .map(|&part_id| { - Ok(Vc::upcast(SingleAssetReference::new( + Ok(Vc::upcast(SingleModuleReference::new( Vc::upcast(EcmascriptModulePartAsset::new( self.full_module, ModulePart::internal(part_id), diff --git a/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs b/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs index cae9654576659..dfd104927115f 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs @@ -4,7 +4,7 @@ use turbopack_core::{ chunk::{availability_info::AvailabilityInfo, ChunkItem}, ident::AssetIdent, module::Module, - reference::AssetReferences, + reference::ModuleReferences, }; use super::{asset::EcmascriptModulePartAsset, part_of_module, split_module}; @@ -78,7 +78,7 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem { #[turbo_tasks::value_impl] impl ChunkItem for EcmascriptModulePartChunkItem { #[turbo_tasks::function] - async fn references(&self) -> Vc { + async fn references(&self) -> Vc { self.module.references() } diff --git a/crates/turbopack-ecmascript/src/typescript/mod.rs b/crates/turbopack-ecmascript/src/typescript/mod.rs index e06008d5d93d6..5b2af79d53749 100644 --- a/crates/turbopack-ecmascript/src/typescript/mod.rs +++ b/crates/turbopack-ecmascript/src/typescript/mod.rs @@ -9,13 +9,14 @@ use turbopack_core::{ ident::AssetIdent, issue::{IssueSeverity, OptionIssueSource}, module::Module, - reference::{AssetReference, AssetReferences}, + raw_module::RawModule, + reference::{ModuleReference, ModuleReferences}, reference_type::{CommonJsReferenceSubType, ReferenceType}, resolve::{ origin::{ResolveOrigin, ResolveOriginExt}, parse::Request, pattern::QueryMap, - ResolveResult, + ModuleResolveResult, }, source::Source, }; @@ -46,7 +47,7 @@ impl Module for TsConfigModuleAsset { } #[turbo_tasks::function] - async fn references(&self) -> Result> { + async fn references(&self) -> Result> { let mut references = Vec::new(); let configs = read_tsconfigs( self.source.content().file_content(), @@ -173,9 +174,9 @@ impl CompilerReference { } #[turbo_tasks::value_impl] -impl AssetReference for CompilerReference { +impl ModuleReference for CompilerReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { cjs_resolve( self.origin, self.request, @@ -211,10 +212,10 @@ impl TsExtendsReference { } #[turbo_tasks::value_impl] -impl AssetReference for TsExtendsReference { +impl ModuleReference for TsExtendsReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(self.config)).into() + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(Vc::upcast(RawModule::new(Vc::upcast(self.config)))).cell() } } @@ -245,9 +246,9 @@ impl TsNodeRequireReference { } #[turbo_tasks::value_impl] -impl AssetReference for TsNodeRequireReference { +impl ModuleReference for TsNodeRequireReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { cjs_resolve( self.origin, self.request, @@ -284,9 +285,9 @@ impl TsConfigTypesReference { } #[turbo_tasks::value_impl] -impl AssetReference for TsConfigTypesReference { +impl ModuleReference for TsConfigTypesReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { type_resolve(self.origin, self.request) } } diff --git a/crates/turbopack-ecmascript/src/typescript/resolve.rs b/crates/turbopack-ecmascript/src/typescript/resolve.rs index e7a58c1925335..859cf3980c36d 100644 --- a/crates/turbopack-ecmascript/src/typescript/resolve.rs +++ b/crates/turbopack-ecmascript/src/typescript/resolve.rs @@ -10,7 +10,7 @@ use turbopack_core::{ file_source::FileSource, ident::AssetIdent, issue::{Issue, IssueExt, IssueSeverity, OptionIssueSource}, - reference::AssetReference, + reference::ModuleReference, reference_type::{ReferenceType, TypeScriptReferenceSubType}, resolve::{ handle_resolve_error, @@ -22,9 +22,9 @@ use turbopack_core::{ origin::{ResolveOrigin, ResolveOriginExt}, parse::Request, pattern::{Pattern, QueryMap}, - resolve, AliasPattern, ResolveResult, + resolve, AliasPattern, ModuleResolveResult, }, - source::{option_asset_to_source, OptionSource, Source}, + source::{OptionSource, Source}, }; #[turbo_tasks::value(shared)] pub struct TsConfigIssue { @@ -135,16 +135,16 @@ async fn resolve_extends( // An empty extends is treated as "./tsconfig" Request::Empty => { let request = Request::parse_string("./tsconfig".to_string()); - Ok(option_asset_to_source(resolve(context, request, resolve_options).first_asset())) + Ok(resolve(context, request, resolve_options).first_source()) } // All other types are treated as module imports, and potentially joined with // "tsconfig.json". This includes "relative" imports like '.' and '..'. _ => { - let mut result = option_asset_to_source(resolve(context, request, resolve_options).first_asset()); + let mut result = resolve(context, request, resolve_options).first_source(); if result.await?.is_none() { let request = Request::parse_string(format!("{extends}/tsconfig")); - result = option_asset_to_source(resolve(context, request, resolve_options).first_asset()); + result = resolve(context, request, resolve_options).first_source(); } Ok(result) } @@ -157,15 +157,14 @@ async fn resolve_extends_rooted_or_relative( resolve_options: Vc, path: &str, ) -> Result> { - let mut result = - option_asset_to_source(resolve(context, request, resolve_options).first_asset()); + let mut result = resolve(context, request, resolve_options).first_source(); // If the file doesn't end with ".json" and we can't find the file, then we have // to try again with it. // https://github.com/microsoft/TypeScript/blob/611a912d/src/compiler/commandLineParser.ts#L3305 if !path.ends_with(".json") && result.await?.is_none() { let request = Request::parse_string(format!("{path}.json")); - result = option_asset_to_source(resolve(context, request, resolve_options).first_asset()); + result = resolve(context, request, resolve_options).first_source(); } Ok(result) } @@ -327,7 +326,7 @@ pub async fn apply_tsconfig_resolve_options( pub async fn type_resolve( origin: Vc>, request: Vc, -) -> Result> { +) -> Result> { let ty = Value::new(ReferenceType::TypeScript( TypeScriptReferenceSubType::Undefined, )); @@ -357,9 +356,10 @@ pub async fn type_resolve( let result = if let Some(types_request) = types_request { let result1 = resolve(context_path, request, options); if !*result1.is_unresolveable().await? { - return Ok(result1); + result1 + } else { + resolve(context_path, types_request, options) } - resolve(context_path, types_request, options) } else { resolve(context_path, request, options) }; @@ -383,9 +383,9 @@ pub struct TypescriptTypesAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for TypescriptTypesAssetReference { +impl ModuleReference for TypescriptTypesAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { + fn resolve_reference(&self) -> Vc { type_resolve(self.origin, self.request) } } diff --git a/crates/turbopack-ecmascript/src/webpack/mod.rs b/crates/turbopack-ecmascript/src/webpack/mod.rs index 27d1fb37fb118..eb261540fe31d 100644 --- a/crates/turbopack-ecmascript/src/webpack/mod.rs +++ b/crates/turbopack-ecmascript/src/webpack/mod.rs @@ -6,14 +6,14 @@ use turbopack_core::{ file_source::FileSource, ident::AssetIdent, module::Module, - reference::{AssetReference, AssetReferences}, + reference::{ModuleReference, ModuleReferences}, reference_type::{CommonJsReferenceSubType, ReferenceType}, resolve::{ origin::{ResolveOrigin, ResolveOriginExt}, parse::Request, - resolve, ResolveResult, + resolve, AffectingResolvingAssetReference, ModuleResolveResult, }, - source::{asset_to_source, Source}, + source::Source, }; use self::{parse::WebpackRuntime, references::module_references}; @@ -59,7 +59,7 @@ impl Module for WebpackModuleAsset { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { module_references(self.source, self.runtime, self.transforms) } } @@ -81,9 +81,9 @@ pub struct WebpackChunkAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for WebpackChunkAssetReference { +impl ModuleReference for WebpackChunkAssetReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { + async fn resolve_reference(&self) -> Result> { let runtime = self.runtime.await?; Ok(match &*runtime { WebpackRuntime::Webpack5 { @@ -99,14 +99,14 @@ impl AssetReference for WebpackChunkAssetReference { let filename = format!("./chunks/{}.js", chunk_id); let source = Vc::upcast(FileSource::new(context_path.join(filename))); - ResolveResult::asset(Vc::upcast(WebpackModuleAsset::new( + ModuleResolveResult::module(Vc::upcast(WebpackModuleAsset::new( source, self.runtime, self.transforms, ))) .into() } - WebpackRuntime::None => ResolveResult::unresolveable().into(), + WebpackRuntime::None => ModuleResolveResult::unresolveable().into(), }) } } @@ -132,10 +132,10 @@ pub struct WebpackEntryAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for WebpackEntryAssetReference { +impl ModuleReference for WebpackEntryAssetReference { #[turbo_tasks::function] - fn resolve_reference(&self) -> Vc { - ResolveResult::asset(Vc::upcast(WebpackModuleAsset::new( + fn resolve_reference(&self) -> Vc { + ModuleResolveResult::module(Vc::upcast(WebpackModuleAsset::new( self.source, self.runtime, self.transforms, @@ -161,9 +161,9 @@ pub struct WebpackRuntimeAssetReference { } #[turbo_tasks::value_impl] -impl AssetReference for WebpackRuntimeAssetReference { +impl ModuleReference for WebpackRuntimeAssetReference { #[turbo_tasks::function] - async fn resolve_reference(&self) -> Result> { + async fn resolve_reference(&self) -> Result> { let ty = Value::new(ReferenceType::CommonJs(CommonJsReferenceSubType::Undefined)); let options = self.origin.resolve_options(ty.clone()); @@ -177,15 +177,15 @@ impl AssetReference for WebpackRuntimeAssetReference { Ok(resolved .await? - .map( + .map_module( |source| async move { Ok(Vc::upcast(WebpackModuleAsset::new( - asset_to_source(source), + source, self.runtime, self.transforms, ))) }, - |r| async move { Ok(r) }, + |r| async move { Ok(Vc::upcast(AffectingResolvingAssetReference::new(r))) }, ) .await? .cell()) diff --git a/crates/turbopack-ecmascript/src/webpack/references.rs b/crates/turbopack-ecmascript/src/webpack/references.rs index 7a30533fedb5c..924dcdaefccaf 100644 --- a/crates/turbopack-ecmascript/src/webpack/references.rs +++ b/crates/turbopack-ecmascript/src/webpack/references.rs @@ -8,7 +8,7 @@ use swc_core::{ }; use turbo_tasks::{Value, Vc}; use turbopack_core::{ - reference::{AssetReference, AssetReferences}, + reference::{ModuleReference, ModuleReferences}, source::Source, }; use turbopack_swc_utils::emitter::IssueEmitter; @@ -24,7 +24,7 @@ pub async fn module_references( source: Vc>, runtime: Vc, transforms: Vc, -) -> Result> { +) -> Result> { let parsed = parse( source, Value::new(EcmascriptModuleAssetType::Ecmascript), @@ -38,7 +38,7 @@ pub async fn module_references( .. } => { let mut references = Vec::new(); - let mut visitor = AssetReferencesVisitor { + let mut visitor = ModuleReferencesVisitor { references: &mut references, runtime, transforms, @@ -61,13 +61,13 @@ pub async fn module_references( } } -struct AssetReferencesVisitor<'a> { +struct ModuleReferencesVisitor<'a> { runtime: Vc, - references: &'a mut Vec>>, + references: &'a mut Vec>>, transforms: Vc, } -impl<'a> Visit for AssetReferencesVisitor<'a> { +impl<'a> Visit for ModuleReferencesVisitor<'a> { fn visit_call_expr(&mut self, call: &CallExpr) { if let Some(member) = call.callee.as_expr().and_then(|e| e.as_member()) { if let (Some(obj), Some(prop)) = (member.obj.as_ident(), member.prop.as_ident()) { diff --git a/crates/turbopack-json/src/lib.rs b/crates/turbopack-json/src/lib.rs index ced0b6abd363b..3954abf8aaea7 100644 --- a/crates/turbopack-json/src/lib.rs +++ b/crates/turbopack-json/src/lib.rs @@ -21,7 +21,7 @@ use turbopack_core::{ }, ident::AssetIdent, module::Module, - reference::AssetReferences, + reference::ModuleReferences, source::Source, }; use turbopack_ecmascript::chunk::{ @@ -112,7 +112,7 @@ impl ChunkItem for JsonChunkItem { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.module.references() } } diff --git a/crates/turbopack-mdx/src/lib.rs b/crates/turbopack-mdx/src/lib.rs index 5acf2221bfe6f..8b0a7d79e60d4 100644 --- a/crates/turbopack-mdx/src/lib.rs +++ b/crates/turbopack-mdx/src/lib.rs @@ -14,7 +14,7 @@ use turbopack_core::{ context::AssetContext, ident::AssetIdent, module::Module, - reference::AssetReferences, + reference::ModuleReferences, resolve::origin::ResolveOrigin, source::Source, virtual_source::VirtualSource, @@ -173,7 +173,7 @@ impl Module for MdxModuleAsset { } #[turbo_tasks::function] - async fn references(self: Vc) -> Result> { + async fn references(self: Vc) -> Result> { Ok(self.failsafe_analyze().await?.references) } } @@ -248,7 +248,7 @@ impl ChunkItem for MdxChunkItem { } #[turbo_tasks::function] - fn references(&self) -> Vc { + fn references(&self) -> Vc { self.module.references() } } diff --git a/crates/turbopack-node/src/render/node_api_source.rs b/crates/turbopack-node/src/render/node_api_source.rs index f0ce7093ceb81..e179ff7027b36 100644 --- a/crates/turbopack-node/src/render/node_api_source.rs +++ b/crates/turbopack-node/src/render/node_api_source.rs @@ -5,7 +5,8 @@ use turbo_tasks::{Value, Vc}; use turbo_tasks_env::ProcessEnv; use turbo_tasks_fs::FileSystemPath; use turbopack_core::introspect::{ - asset::IntrospectableAsset, Introspectable, IntrospectableChildren, + module::IntrospectableModule, output_asset::IntrospectableOutputAsset, Introspectable, + IntrospectableChildren, }; use turbopack_dev_server::source::{ route_tree::{BaseSegment, RouteTree, RouteType}, @@ -187,15 +188,15 @@ impl Introspectable for NodeApiContentSource { let entry = entry.await?; set.insert(( Vc::cell("module".to_string()), - IntrospectableAsset::new(Vc::upcast(entry.module)), + IntrospectableModule::new(Vc::upcast(entry.module)), )); set.insert(( Vc::cell("intermediate asset".to_string()), - IntrospectableAsset::new(Vc::upcast(get_intermediate_asset( + IntrospectableOutputAsset::new(get_intermediate_asset( entry.chunking_context, entry.module, entry.runtime_entries, - ))), + )), )); } Ok(Vc::cell(set)) diff --git a/crates/turbopack-node/src/render/rendered_source.rs b/crates/turbopack-node/src/render/rendered_source.rs index 0a250008af486..707c3d150ae96 100644 --- a/crates/turbopack-node/src/render/rendered_source.rs +++ b/crates/turbopack-node/src/render/rendered_source.rs @@ -5,7 +5,10 @@ use turbo_tasks::{Value, Vc}; use turbo_tasks_env::ProcessEnv; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ - introspect::{asset::IntrospectableAsset, Introspectable, IntrospectableChildren}, + introspect::{ + module::IntrospectableModule, output_asset::IntrospectableOutputAsset, Introspectable, + IntrospectableChildren, + }, issue::IssueContextExt, module::Module, output::OutputAsset, @@ -273,15 +276,15 @@ impl Introspectable for NodeRenderContentSource { let entry = entry.await?; set.insert(( Vc::cell("module".to_string()), - IntrospectableAsset::new(Vc::upcast(entry.module)), + IntrospectableModule::new(Vc::upcast(entry.module)), )); set.insert(( Vc::cell("intermediate asset".to_string()), - IntrospectableAsset::new(Vc::upcast(get_intermediate_asset( + IntrospectableOutputAsset::new(get_intermediate_asset( entry.chunking_context, entry.module, entry.runtime_entries, - ))), + )), )); } Ok(Vc::cell(set)) diff --git a/crates/turbopack-static/src/lib.rs b/crates/turbopack-static/src/lib.rs index 08bc20ea10f1e..885ed40b92253 100644 --- a/crates/turbopack-static/src/lib.rs +++ b/crates/turbopack-static/src/lib.rs @@ -26,7 +26,7 @@ use turbopack_core::{ ident::AssetIdent, module::Module, output::{OutputAsset, OutputAssets}, - reference::{AssetReferences, SingleAssetReference}, + reference::{ModuleReferences, SingleOutputAssetReference}, source::Source, }; use turbopack_css::embed::{CssEmbed, CssEmbeddable}; @@ -185,8 +185,8 @@ impl ChunkItem for ModuleChunkItem { } #[turbo_tasks::function] - async fn references(&self) -> Result> { - Ok(Vc::cell(vec![Vc::upcast(SingleAssetReference::new( + async fn references(&self) -> Result> { + Ok(Vc::cell(vec![Vc::upcast(SingleOutputAssetReference::new( Vc::upcast(self.static_asset), Vc::cell(format!( "static(url) {}", diff --git a/crates/turbopack/src/lib.rs b/crates/turbopack/src/lib.rs index b203205d77809..9570fcc3f5dcf 100644 --- a/crates/turbopack/src/lib.rs +++ b/crates/turbopack/src/lib.rs @@ -45,10 +45,10 @@ use turbopack_core::{ raw_module::RawModule, reference_type::{EcmaScriptModulesReferenceSubType, InnerAssets, ReferenceType}, resolve::{ - options::ResolveOptions, origin::PlainResolveOrigin, parse::Request, resolve, ModulePart, - ResolveResult, + options::ResolveOptions, origin::PlainResolveOrigin, parse::Request, resolve, + AffectingResolvingAssetReference, ModulePart, ModuleResolveResult, ResolveResult, }, - source::{asset_to_source, Source}, + source::Source, }; pub use turbopack_css as css; pub use turbopack_ecmascript as ecmascript; @@ -421,7 +421,7 @@ impl AssetContext for ModuleAssetContext { request: Vc, resolve_options: Vc, reference_type: Value, - ) -> Result> { + ) -> Result> { let context_path = origin_path.parent().resolve().await?; let result = resolve(context_path, request, resolve_options); @@ -444,21 +444,19 @@ impl AssetContext for ModuleAssetContext { self: Vc, result: Vc, reference_type: Value, - ) -> Result> { + ) -> Result> { Ok(result .await? - .map( - |a| { + .map_module( + |source| { let reference_type = reference_type.clone(); async move { Ok(Vc::upcast( - self.process(asset_to_source(a), reference_type) - .resolve() - .await?, + self.process(source, reference_type).resolve().await?, )) } }, - |i| async move { Ok(i) }, + |i| async move { Ok(Vc::upcast(AffectingResolvingAssetReference::new(i))) }, ) .await? .into())