Commit a676aa7e authored by Tobias Koppers's avatar Tobias Koppers Committed by Tobias Koppers

Turbopack: Use operations for global information and module graph

parent aa3ba7ed
......@@ -437,8 +437,8 @@ pub async fn analyze_module_graphs(module_graphs: Vc<ModuleGraphs>) -> Result<Vc
let mut all_modules = FxIndexSet::default();
let mut all_edges = FxIndexSet::default();
let mut all_async_edges = FxIndexSet::default();
for &module_graph in module_graphs.await? {
let module_graph = module_graph.await?;
for module_graph in module_graphs.await?.iter() {
let module_graph = module_graph.connect().await?;
module_graph.traverse_edges_unordered(|parent, node| {
if let Some((parent_node, reference)) = parent {
all_modules.insert(parent_node);
......
......@@ -1008,8 +1008,8 @@ impl AppProject {
};
Ok(BaseAndFullModuleGraph {
base: base.connect().to_resolved().await?,
full: full.connect().to_resolved().await?,
base,
full,
binding_usage_info,
}
.cell())
......@@ -1287,7 +1287,7 @@ impl AppEndpoint {
AssetIdent::from_path(project.project_path().owned().await?)
.with_modifier(rcstr!("client-shared-chunks")),
this.app_project.client_runtime_entries(),
*module_graphs.full,
module_graphs.full.connect(),
*client_chunking_context,
);
......@@ -1305,14 +1305,14 @@ impl AppEndpoint {
let per_page_module_graph = *project.per_page_module_graph().await?;
let next_dynamic_imports =
NextDynamicGraphs::new(*module_graphs.base, per_page_module_graph)
NextDynamicGraphs::new(module_graphs.base.connect(), per_page_module_graph)
.get_next_dynamic_imports_for_endpoint(*rsc_entry)
.await?;
let is_production = project.next_mode().await?.is_production();
let client_references =
ClientReferencesGraphs::new(*module_graphs.base, per_page_module_graph)
ClientReferencesGraphs::new(module_graphs.base.connect(), per_page_module_graph)
.get_client_references_for_endpoint(
*rsc_entry,
matches!(this.ty, AppEndpointType::Page { .. }),
......@@ -1324,7 +1324,7 @@ impl AppEndpoint {
let client_references_chunks = get_app_client_references_chunks(
*client_references,
*module_graphs.full,
module_graphs.full.connect(),
*client_chunking_context,
availability_info,
ssr_chunking_context.map(|ctx| *ctx),
......@@ -1432,7 +1432,7 @@ impl AppEndpoint {
}
}
let actions = ServerActionsGraphs::new(*module_graphs.base, per_page_module_graph)
let actions = ServerActionsGraphs::new(module_graphs.base.connect(), per_page_module_graph)
.get_server_actions_for_endpoint(
*rsc_entry,
match runtime {
......@@ -1451,7 +1451,7 @@ impl AppEndpoint {
NextRuntime::Edge => Vc::upcast(this.app_project.edge_rsc_module_context()),
NextRuntime::NodeJs => Vc::upcast(this.app_project.rsc_module_context()),
},
*module_graphs.full,
module_graphs.full.connect(),
this.app_project
.project()
.runtime_chunking_context(process_client_assets, runtime),
......@@ -1469,7 +1469,7 @@ impl AppEndpoint {
*server_action_manifest_loader,
server_path.clone(),
process_client_assets,
*module_graphs.full,
module_graphs.full.connect(),
)
.to_resolved()
.await?;
......@@ -1491,7 +1491,12 @@ impl AppEndpoint {
client_references_chunks,
client_chunking_context,
ssr_chunking_context,
async_module_info: module_graphs.full.async_module_info().to_resolved().await?,
async_module_info: module_graphs
.full
.connect()
.async_module_info()
.to_resolved()
.await?,
next_config: project.next_config().to_resolved().await?,
runtime,
mode: *project.next_mode().await?,
......@@ -1574,7 +1579,7 @@ impl AppEndpoint {
if emit_manifests == EmitManifests::Full {
let dynamic_import_entries = collect_next_dynamic_chunks(
*module_graphs.full,
module_graphs.full.connect(),
*client_chunking_context,
next_dynamic_imports,
NextDynamicChunkAvailability::ClientReferences(
......@@ -1698,7 +1703,7 @@ impl AppEndpoint {
let loadable_manifest_output = if emit_manifests == EmitManifests::Full {
// create react-loadable-manifest for next/dynamic
let dynamic_import_entries = collect_next_dynamic_chunks(
*module_graphs.full,
module_graphs.full.connect(),
*client_chunking_context,
next_dynamic_imports,
NextDynamicChunkAvailability::ClientReferences(
......
......@@ -30,7 +30,7 @@ use crate::{
paths::{
all_asset_paths, get_js_paths_from_root, get_wasm_paths_from_root, wasm_paths_to_bindings,
},
project::Project,
project::{Project, get_module_graph_operation},
route::{Endpoint, EndpointOutput, EndpointOutputPaths, ModuleGraphs},
};
......@@ -247,9 +247,11 @@ impl Endpoint for InstrumentationEndpoint {
#[turbo_tasks::function]
async fn module_graphs(self: Vc<Self>) -> Result<Vc<ModuleGraphs>> {
let this = self.await?;
let module = self.entry_module();
let module_graph = this.project.module_graph(module).to_resolved().await?;
Ok(Vc::cell(vec![module_graph]))
let module = self.entry_module().to_resolved().await?;
Ok(Vc::cell(vec![get_module_graph_operation(
this.project,
module,
)]))
}
#[turbo_tasks::function]
......
......@@ -33,7 +33,7 @@ use crate::{
all_asset_paths, all_paths_in_root, get_asset_paths_from_root, get_js_paths_from_root,
get_wasm_paths_from_root, paths_to_bindings, wasm_paths_to_bindings,
},
project::Project,
project::{Project, get_module_graph_operation},
route::{Endpoint, EndpointOutput, EndpointOutputPaths, ModuleGraphs},
};
......@@ -394,12 +394,11 @@ impl Endpoint for MiddlewareEndpoint {
#[turbo_tasks::function]
async fn module_graphs(self: Vc<Self>) -> Result<Vc<ModuleGraphs>> {
let this = self.await?;
let module_graph = this
.project
.module_graph(self.entry_module())
.to_resolved()
.await?;
Ok(Vc::cell(vec![module_graph]))
let module = self.entry_module().to_resolved().await?;
Ok(Vc::cell(vec![get_module_graph_operation(
this.project,
module,
)]))
}
#[turbo_tasks::function]
......
......@@ -78,7 +78,7 @@ use crate::{
all_asset_paths, all_paths_in_root, get_asset_paths_from_root, get_js_paths_from_root,
get_wasm_paths_from_root, paths_to_bindings, wasm_paths_to_bindings,
},
project::Project,
project::{Project, get_module_graph_for_modules_operation},
route::{Endpoint, EndpointOutput, EndpointOutputPaths, ModuleGraphs, Route, Routes},
sri_manifest::get_sri_manifest_asset,
};
......@@ -699,71 +699,13 @@ impl PageEndpoint {
}
#[turbo_tasks::function]
async fn client_module_graph(self: Vc<Self>) -> Result<Vc<ModuleGraph>> {
let this = self.await?;
let project = this.pages_project.project();
let evaluatable_assets = self.client_evaluatable_assets();
Ok(project.module_graph_for_modules(evaluatable_assets))
async fn client_module_graph(self: ResolvedVc<Self>) -> Result<Vc<ModuleGraph>> {
Ok(get_pages_client_module_graph_operation(self).connect())
}
#[turbo_tasks::function]
async fn ssr_module_graph(self: Vc<Self>) -> Result<Vc<ModuleGraph>> {
let this = self.await?;
let project = this.pages_project.project();
if *project.per_page_module_graph().await? {
let next_mode = project.next_mode();
let next_mode_ref = next_mode.await?;
let should_trace = next_mode_ref.is_production();
let should_read_binding_usage = next_mode_ref.is_production();
let ssr_chunk_module = self.internal_ssr_chunk_module().await?;
// Implements layout segment optimization to compute a graph "chain" for document, app,
// page
let mut graphs = vec![];
let mut visited_modules = VisitedModules::empty();
for module in [
ssr_chunk_module.document_module,
ssr_chunk_module.app_module,
]
.into_iter()
.flatten()
{
let graph = SingleModuleGraph::new_with_entries_visited_intern(
vec![ChunkGroupEntry::Shared(module)],
visited_modules,
should_trace,
should_read_binding_usage,
);
graphs.push(graph);
visited_modules = VisitedModules::concatenate(visited_modules, graph);
}
let graph = SingleModuleGraph::new_with_entries_visited_intern(
vec![ChunkGroupEntry::Entry(vec![ssr_chunk_module.ssr_module])],
visited_modules,
should_trace,
should_read_binding_usage,
);
graphs.push(graph);
let remove_unused_imports = *project
.next_config()
.turbopack_remove_unused_imports(next_mode)
.await?;
let graph = if remove_unused_imports {
let graph = ModuleGraph::from_graphs(graphs.clone());
let binding_usage_info = compute_binding_usage_info(graph, true);
ModuleGraph::from_graphs_without_unused_references(graphs, binding_usage_info)
} else {
ModuleGraph::from_graphs(graphs)
};
Ok(graph.connect())
} else {
Ok(*project.whole_app_module_graphs().await?.full)
}
async fn ssr_module_graph(self: ResolvedVc<Self>) -> Result<Vc<ModuleGraph>> {
Ok(get_pages_ssr_module_graph_operation(self).connect())
}
#[turbo_tasks::function]
......@@ -1712,13 +1654,12 @@ impl Endpoint for PageEndpoint {
#[turbo_tasks::function]
async fn module_graphs(self: Vc<Self>) -> Result<Vc<ModuleGraphs>> {
let client_module_graph = self.client_module_graph().to_resolved().await?;
let ssr_module_graph = self.ssr_module_graph().to_resolved().await?;
Ok(Vc::cell(if client_module_graph != ssr_module_graph {
vec![client_module_graph, ssr_module_graph]
} else {
vec![ssr_module_graph]
}))
let this = self.to_resolved().await?;
let client_module_graph = get_pages_client_module_graph_operation(this);
let ssr_module_graph = get_pages_ssr_module_graph_operation(this);
// Note: We can't easily deduplicate these anymore since OperationVc
// doesn't implement Eq, but that's fine - they're operation references
Ok(Vc::cell(vec![client_module_graph, ssr_module_graph]))
}
#[turbo_tasks::function]
......@@ -1787,3 +1728,75 @@ pub enum SsrChunk {
regions: Option<Vec<RcStr>>,
},
}
#[turbo_tasks::function(operation)]
async fn get_pages_client_module_graph_operation(
endpoint: ResolvedVc<PageEndpoint>,
) -> Result<Vc<ModuleGraph>> {
let this = endpoint.await?;
let project = this.pages_project.project().to_resolved().await?;
let evaluatable_assets = endpoint.client_evaluatable_assets().to_resolved().await?;
Ok(get_module_graph_for_modules_operation(project, evaluatable_assets).connect())
}
#[turbo_tasks::function(operation)]
async fn get_pages_ssr_module_graph_operation(
endpoint: ResolvedVc<PageEndpoint>,
) -> Result<Vc<ModuleGraph>> {
let this = endpoint.await?;
let project = this.pages_project.project();
if *project.per_page_module_graph().await? {
let next_mode = project.next_mode();
let next_mode_ref = next_mode.await?;
let should_trace = next_mode_ref.is_production();
let should_read_binding_usage = next_mode_ref.is_production();
let ssr_chunk_module = endpoint.internal_ssr_chunk_module().await?;
// Implements layout segment optimization to compute a graph "chain" for document, app,
// page
let mut graphs = vec![];
let mut visited_modules = VisitedModules::empty();
for module in [
ssr_chunk_module.document_module,
ssr_chunk_module.app_module,
]
.into_iter()
.flatten()
{
let graph = SingleModuleGraph::new_with_entries_visited_intern(
vec![ChunkGroupEntry::Shared(module)],
visited_modules,
should_trace,
should_read_binding_usage,
);
graphs.push(graph);
visited_modules = VisitedModules::concatenate(visited_modules, graph);
}
let graph = SingleModuleGraph::new_with_entries_visited_intern(
vec![ChunkGroupEntry::Entry(vec![ssr_chunk_module.ssr_module])],
visited_modules,
should_trace,
should_read_binding_usage,
);
graphs.push(graph);
let remove_unused_imports = *project
.next_config()
.turbopack_remove_unused_imports(next_mode)
.await?;
let graph = if remove_unused_imports {
let graph = ModuleGraph::from_graphs(graphs.clone());
let binding_usage_info = compute_binding_usage_info(graph, true);
ModuleGraph::from_graphs_without_unused_references(graphs, binding_usage_info)
} else {
ModuleGraph::from_graphs(graphs)
};
Ok(graph.connect())
} else {
Ok(project.whole_app_module_graphs().await?.full.connect())
}
}
This diff is collapsed.
......@@ -42,7 +42,7 @@ pub enum Route {
}
#[turbo_tasks::value(transparent)]
pub struct ModuleGraphs(Vec<ResolvedVc<ModuleGraph>>);
pub struct ModuleGraphs(Vec<OperationVc<ModuleGraph>>);
#[turbo_tasks::value_trait]
pub trait Endpoint {
......
......@@ -205,8 +205,8 @@ impl Asset for RoutesHashesManifestAsset {
#[turbo_tasks::function]
async fn content(&self) -> Result<Vc<AssetContent>> {
let module_graphs = self.project.whole_app_module_graphs().await?;
let base_module_graph = *module_graphs.base;
let full_module_graph = *module_graphs.full;
let base_module_graph = module_graphs.base.connect();
let full_module_graph = module_graphs.full.connect();
let mut entrypoint_hashes = FxIndexMap::default();
......
......@@ -3,7 +3,7 @@ use std::collections::BTreeSet;
use anyhow::Result;
use bincode::{Decode, Encode};
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
use turbo_tasks::{OperationVc, ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
use turbo_tasks_fs::FileSystemPath;
use turbopack::module_options::{
CssOptionsContext, EcmascriptOptionsContext, JsxTransformOptions, ModuleRule,
......@@ -23,7 +23,7 @@ use turbopack_core::{
environment::{BrowserEnvironment, Environment, ExecutionEnvironment},
free_var_references,
issue::IssueSeverity,
module_graph::binding_usage_info::OptionBindingUsageInfo,
module_graph::binding_usage_info::BindingUsageInfo,
resolve::{parse::Request, pattern::Pattern},
};
use turbopack_css::chunk::CssChunkType;
......@@ -434,9 +434,9 @@ pub struct ClientChunkingContextOptions {
pub client_root_to_root_path: RcStr,
pub asset_prefix: Vc<RcStr>,
pub environment: Vc<Environment>,
pub module_id_strategy: Vc<ModuleIdStrategy>,
pub export_usage: Vc<OptionBindingUsageInfo>,
pub unused_references: Vc<UnusedReferences>,
pub module_id_strategy: OperationVc<ModuleIdStrategy>,
pub export_usage: Option<OperationVc<BindingUsageInfo>>,
pub unused_references: OperationVc<UnusedReferences>,
pub minify: Vc<bool>,
pub source_maps: Vc<SourceMapsType>,
pub no_mangling: Vc<bool>,
......@@ -495,9 +495,8 @@ pub async fn get_client_chunking_context(
.source_maps(*source_maps.await?)
.asset_base_path(Some(asset_prefix))
.current_chunk_method(CurrentChunkMethod::DocumentCurrentScript)
.export_usage(*export_usage.await?)
.unused_references(unused_references.to_resolved().await?)
.module_id_strategy(module_id_strategy.to_resolved().await?)
.unused_references(unused_references)
.module_id_strategy(module_id_strategy)
.debug_ids(*debug_ids.await?)
.should_use_absolute_url_references(*should_use_absolute_url_references.await?)
.nested_async_availability(*nested_async_chunking.await?)
......@@ -507,6 +506,10 @@ pub async fn get_client_chunking_context(
static_suffix: css_url_suffix.to_resolved().await?,
});
if let Some(export_usage) = export_usage {
builder = builder.export_usage(export_usage);
}
if next_mode.is_development() {
builder = builder
.hot_module_replacement()
......
use anyhow::Result;
use bincode::{Decode, Encode};
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
use turbo_tasks::{OperationVc, ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
use turbo_tasks_fs::FileSystemPath;
use turbopack_browser::BrowserChunkingContext;
use turbopack_core::{
......@@ -13,7 +13,7 @@ use turbopack_core::{
environment::{EdgeWorkerEnvironment, Environment, ExecutionEnvironment, NodeJsVersion},
free_var_references,
issue::IssueSeverity,
module_graph::binding_usage_info::OptionBindingUsageInfo,
module_graph::binding_usage_info::BindingUsageInfo,
};
use turbopack_css::chunk::CssChunkType;
use turbopack_ecmascript::chunk::EcmascriptChunkType;
......@@ -191,9 +191,9 @@ pub struct EdgeChunkingContextOptions {
pub node_root: FileSystemPath,
pub output_root_to_root_path: Vc<RcStr>,
pub environment: Vc<Environment>,
pub module_id_strategy: Vc<ModuleIdStrategy>,
pub export_usage: Vc<OptionBindingUsageInfo>,
pub unused_references: Vc<UnusedReferences>,
pub module_id_strategy: OperationVc<ModuleIdStrategy>,
pub export_usage: Option<OperationVc<BindingUsageInfo>>,
pub unused_references: OperationVc<UnusedReferences>,
pub turbo_minify: Vc<bool>,
pub turbo_source_maps: Vc<SourceMapsType>,
pub no_mangling: Vc<bool>,
......@@ -253,12 +253,15 @@ pub async fn get_edge_chunking_context_with_client_assets(
MinifyType::NoMinify
})
.source_maps(*turbo_source_maps.await?)
.module_id_strategy(module_id_strategy.to_resolved().await?)
.export_usage(*export_usage.await?)
.unused_references(unused_references.to_resolved().await?)
.module_id_strategy(module_id_strategy)
.unused_references(unused_references)
.nested_async_availability(*nested_async_chunking.await?)
.worker_forwarded_globals(worker_forwarded_globals());
if let Some(export_usage) = export_usage {
builder = builder.export_usage(export_usage);
}
if !next_mode.is_development() {
builder = builder
.chunking_config(
......@@ -344,12 +347,15 @@ pub async fn get_edge_chunking_context(
MinifyType::NoMinify
})
.source_maps(*turbo_source_maps.await?)
.module_id_strategy(module_id_strategy.to_resolved().await?)
.export_usage(*export_usage.await?)
.unused_references(unused_references.to_resolved().await?)
.module_id_strategy(module_id_strategy)
.unused_references(unused_references)
.nested_async_availability(*nested_async_chunking.await?)
.worker_forwarded_globals(worker_forwarded_globals());
if let Some(export_usage) = export_usage {
builder = builder.export_usage(export_usage);
}
if !next_mode.is_development() {
builder = builder
.chunking_config(
......
......@@ -3,7 +3,7 @@ use std::collections::BTreeSet;
use anyhow::{Result, bail};
use bincode::{Decode, Encode};
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
use turbo_tasks::{OperationVc, ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
use turbo_tasks_fs::FileSystemPath;
use turbopack::{
module_options::{
......@@ -22,7 +22,7 @@ use turbopack_core::{
compile_time_info::{CompileTimeDefines, CompileTimeInfo, FreeVarReferences},
environment::{Environment, ExecutionEnvironment, NodeJsEnvironment, NodeJsVersion},
issue::IssueSeverity,
module_graph::binding_usage_info::OptionBindingUsageInfo,
module_graph::binding_usage_info::BindingUsageInfo,
target::CompileTarget,
};
use turbopack_css::chunk::CssChunkType;
......@@ -992,9 +992,9 @@ pub struct ServerChunkingContextOptions {
pub node_root: FileSystemPath,
pub node_root_to_root_path: RcStr,
pub environment: Vc<Environment>,
pub module_id_strategy: Vc<ModuleIdStrategy>,
pub export_usage: Vc<OptionBindingUsageInfo>,
pub unused_references: Vc<UnusedReferences>,
pub module_id_strategy: OperationVc<ModuleIdStrategy>,
pub export_usage: Option<OperationVc<BindingUsageInfo>>,
pub unused_references: OperationVc<UnusedReferences>,
pub minify: Vc<bool>,
pub source_maps: Vc<SourceMapsType>,
pub no_mangling: Vc<bool>,
......@@ -1067,14 +1067,17 @@ pub async fn get_server_chunking_context_with_client_assets(
MinifyType::NoMinify
})
.source_maps(*source_maps.await?)
.module_id_strategy(module_id_strategy.to_resolved().await?)
.export_usage(*export_usage.await?)
.unused_references(unused_references.to_resolved().await?)
.module_id_strategy(module_id_strategy)
.unused_references(unused_references)
.file_tracing(next_mode.is_production())
.debug_ids(*debug_ids.await?)
.nested_async_availability(*nested_async_chunking.await?)
.worker_forwarded_globals(worker_forwarded_globals());
if let Some(export_usage) = export_usage {
builder = builder.export_usage(export_usage);
}
builder = builder.source_map_source_type(if next_mode.is_development() {
SourceMapSourceType::AbsoluteFileUri
} else {
......@@ -1165,14 +1168,17 @@ pub async fn get_server_chunking_context(
MinifyType::NoMinify
})
.source_maps(*source_maps.await?)
.module_id_strategy(module_id_strategy.to_resolved().await?)
.export_usage(*export_usage.await?)
.unused_references(unused_references.to_resolved().await?)
.module_id_strategy(module_id_strategy)
.unused_references(unused_references)
.file_tracing(next_mode.is_production())
.debug_ids(*debug_ids.await?)
.nested_async_availability(*nested_async_chunking.await?)
.worker_forwarded_globals(worker_forwarded_globals());
if let Some(export_usage) = export_usage {
builder = builder.export_usage(export_usage);
}
if next_mode.is_development() {
builder = builder.source_map_source_type(SourceMapSourceType::AbsoluteFileUri);
} else {
......
use anyhow::{Context, Result, bail};
use tracing::Instrument;
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{FxIndexMap, ResolvedVc, TaskInput, TryJoinIterExt, Upcast, ValueToString, Vc};
use turbo_tasks::{FxIndexMap, OperationVc, ResolvedVc, TaskInput, TryJoinIterExt, Upcast, ValueToString, Vc};
use turbo_tasks_fs::FileSystemPath;
use turbo_tasks_hash::HashAlgorithm;
use turbopack_core::{
......@@ -133,17 +133,17 @@ impl BrowserChunkingContextBuilder {
self
}
pub fn module_id_strategy(mut self, module_id_strategy: ResolvedVc<ModuleIdStrategy>) -> Self {
pub fn module_id_strategy(mut self, module_id_strategy: OperationVc<ModuleIdStrategy>) -> Self {
self.chunking_context.module_id_strategy = Some(module_id_strategy);
self
}
pub fn export_usage(mut self, export_usage: Option<ResolvedVc<BindingUsageInfo>>) -> Self {
self.chunking_context.export_usage = export_usage;
pub fn export_usage(mut self, export_usage: OperationVc<BindingUsageInfo>) -> Self {
self.chunking_context.export_usage = Some(export_usage);
self
}
pub fn unused_references(mut self, unused_references: ResolvedVc<UnusedReferences>) -> Self {
pub fn unused_references(mut self, unused_references: OperationVc<UnusedReferences>) -> Self {
self.chunking_context.unused_references = Some(unused_references);
self
}
......@@ -301,11 +301,11 @@ pub struct BrowserChunkingContext {
/// Whether to use manifest chunks for lazy compilation
manifest_chunks: bool,
/// The module id strategy to use
module_id_strategy: Option<ResolvedVc<ModuleIdStrategy>>,
module_id_strategy: Option<OperationVc<ModuleIdStrategy>>,
/// The module export usage info, if available.
export_usage: Option<ResolvedVc<BindingUsageInfo>>,
export_usage: Option<OperationVc<BindingUsageInfo>>,
/// Which references are unused and should be skipped (e.g. during codegen).
unused_references: Option<ResolvedVc<UnusedReferences>>,
unused_references: Option<OperationVc<UnusedReferences>>,
/// The chunking configs
chunking_configs: Vec<(ResolvedVc<Box<dyn ChunkType>>, ChunkingConfig)>,
/// Whether to use absolute URLs for static assets (e.g. in CSS: `url("/absolute/path")`)
......@@ -868,9 +868,9 @@ impl ChunkingContext for BrowserChunkingContext {
#[turbo_tasks::function]
fn chunk_item_id_strategy(&self) -> Vc<ModuleIdStrategy> {
*self
.module_id_strategy
.unwrap_or_else(|| ModuleIdStrategy::default().resolved_cell())
self.module_id_strategy
.map(|v| v.connect())
.unwrap_or_else(|| ModuleIdStrategy::default().cell())
}
#[turbo_tasks::function]
......@@ -914,7 +914,7 @@ impl ChunkingContext for BrowserChunkingContext {
module: ResolvedVc<Box<dyn Module>>,
) -> Result<Vc<ModuleExportUsage>> {
if let Some(export_usage) = self.export_usage {
Ok(export_usage.await?.used_exports(module).await?)
Ok(export_usage.connect().await?.used_exports(module).await?)
} else {
Ok(ModuleExportUsage::all())
}
......@@ -923,7 +923,7 @@ impl ChunkingContext for BrowserChunkingContext {
#[turbo_tasks::function]
fn unused_references(&self) -> Vc<UnusedReferences> {
if let Some(unused_references) = self.unused_references {
*unused_references
unused_references.connect()
} else {
Vc::cell(Default::default())
}
......
......@@ -32,7 +32,7 @@ use turbopack_core::{
module::Module,
module_graph::{
ModuleGraph, SingleModuleGraph,
binding_usage_info::compute_binding_usage_info,
binding_usage_info::{compute_binding_usage_info, get_unused_references},
chunk_group_info::{ChunkGroup, ChunkGroupEntry},
},
output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
......@@ -316,17 +316,11 @@ async fn build_internal(
);
let mut module_graph = ModuleGraph::from_single_graph(single_graph);
let binding_usage = compute_binding_usage_info(module_graph, true);
let unused_references = binding_usage
.connect()
.unused_references()
.to_resolved()
.await?;
let unused_references = get_unused_references(binding_usage);
module_graph =
ModuleGraph::from_single_graph_without_unused_references(single_graph, binding_usage);
let module_id_strategy = get_global_module_id_strategy(module_graph);
let module_graph = module_graph.connect();
let module_id_strategy = get_global_module_id_strategy(module_graph)
.to_resolved()
.await?;
let chunking_context: Vc<Box<dyn ChunkingContext>> = match target {
Target::Browser => {
......@@ -352,7 +346,7 @@ async fn build_internal(
)
.source_maps(source_maps_type)
.module_id_strategy(module_id_strategy)
.export_usage(Some(binding_usage.connect().to_resolved().await?))
.export_usage(binding_usage)
.unused_references(unused_references)
.current_chunk_method(CurrentChunkMethod::DocumentCurrentScript)
.minify_type(minify_type);
......@@ -403,7 +397,7 @@ async fn build_internal(
)
.source_maps(source_maps_type)
.module_id_strategy(module_id_strategy)
.export_usage(Some(binding_usage.connect().to_resolved().await?))
.export_usage(binding_usage)
.unused_references(unused_references)
.minify_type(minify_type);
......
......@@ -94,6 +94,11 @@ impl BindingUsageInfo {
}
}
#[turbo_tasks::function(operation)]
pub fn get_unused_references(binding_usage: OperationVc<BindingUsageInfo>) -> Vc<UnusedReferences> {
binding_usage.connect().unused_references()
}
#[turbo_tasks::function(operation)]
pub async fn compute_binding_usage_info(
graph: OperationVc<ModuleGraph>,
......
use anyhow::{Context, Result, bail};
use tracing::Instrument;
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{FxIndexMap, ResolvedVc, TryJoinIterExt, Upcast, ValueToString, Vc};
use turbo_tasks::{FxIndexMap, OperationVc, ResolvedVc, TryJoinIterExt, Upcast, ValueToString, Vc};
use turbo_tasks_fs::FileSystemPath;
use turbopack_core::{
asset::Asset,
......@@ -120,17 +120,17 @@ impl NodeJsChunkingContextBuilder {
self
}
pub fn module_id_strategy(mut self, module_id_strategy: ResolvedVc<ModuleIdStrategy>) -> Self {
pub fn module_id_strategy(mut self, module_id_strategy: OperationVc<ModuleIdStrategy>) -> Self {
self.chunking_context.module_id_strategy = Some(module_id_strategy);
self
}
pub fn export_usage(mut self, export_usage: Option<ResolvedVc<BindingUsageInfo>>) -> Self {
self.chunking_context.export_usage = export_usage;
pub fn export_usage(mut self, export_usage: OperationVc<BindingUsageInfo>) -> Self {
self.chunking_context.export_usage = Some(export_usage);
self
}
pub fn unused_references(mut self, unused_references: ResolvedVc<UnusedReferences>) -> Self {
pub fn unused_references(mut self, unused_references: OperationVc<UnusedReferences>) -> Self {
self.chunking_context.unused_references = Some(unused_references);
self
}
......@@ -219,11 +219,11 @@ pub struct NodeJsChunkingContext {
/// Whether to use manifest chunks for lazy compilation
manifest_chunks: bool,
/// The strategy to use for generating module ids
module_id_strategy: Option<ResolvedVc<ModuleIdStrategy>>,
module_id_strategy: Option<OperationVc<ModuleIdStrategy>>,
/// The module export usage info, if available.
export_usage: Option<ResolvedVc<BindingUsageInfo>>,
export_usage: Option<OperationVc<BindingUsageInfo>>,
/// Which references are unused and should be skipped (e.g. during codegen).
unused_references: Option<ResolvedVc<UnusedReferences>>,
unused_references: Option<OperationVc<UnusedReferences>>,
/// The strategy to use for generating source map source uris
source_map_source_type: SourceMapSourceType,
/// The chunking configs
......@@ -638,9 +638,9 @@ impl ChunkingContext for NodeJsChunkingContext {
#[turbo_tasks::function]
fn chunk_item_id_strategy(&self) -> Vc<ModuleIdStrategy> {
*self
.module_id_strategy
.unwrap_or_else(|| ModuleIdStrategy::default().resolved_cell())
self.module_id_strategy
.map(|v| v.connect())
.unwrap_or_else(|| ModuleIdStrategy::default().cell())
}
#[turbo_tasks::function]
......@@ -689,7 +689,7 @@ impl ChunkingContext for NodeJsChunkingContext {
module: ResolvedVc<Box<dyn Module>>,
) -> Result<Vc<ModuleExportUsage>> {
if let Some(export_usage) = self.export_usage {
Ok(export_usage.await?.used_exports(module).await?)
Ok(export_usage.connect().await?.used_exports(module).await?)
} else {
Ok(ModuleExportUsage::all())
}
......@@ -698,7 +698,7 @@ impl ChunkingContext for NodeJsChunkingContext {
#[turbo_tasks::function]
fn unused_references(&self) -> Vc<UnusedReferences> {
if let Some(unused_references) = self.unused_references {
*unused_references
unused_references.connect()
} else {
Vc::cell(Default::default())
}
......
......@@ -39,7 +39,8 @@ use turbopack_core::{
ident::Layer,
issue::{CollectibleIssuesExt, IssueFilter},
module_graph::{
ModuleGraph, SingleModuleGraph, binding_usage_info::compute_binding_usage_info,
ModuleGraph, SingleModuleGraph,
binding_usage_info::{compute_binding_usage_info, get_unused_references},
},
reference_type::{InnerAssets, ReferenceType},
resolve::{
......@@ -530,22 +531,14 @@ async fn run_test_operation(prepared_test: ResolvedVc<PreparedTest>) -> Result<V
}
} else {
MinifyType::NoMinify
})
.export_usage(if options.remove_unused_exports {
Some(binding_usage.unwrap().connect().to_resolved().await?)
} else {
None
});
if options.remove_unused_exports {
builder = builder.export_usage(binding_usage.unwrap());
}
if options.remove_unused_imports {
builder = builder.unused_references(
binding_usage
.unwrap()
.connect()
.unused_references()
.to_resolved()
.await?,
);
builder = builder.unused_references(get_unused_references(binding_usage.unwrap()));
}
if options.production_chunking {
......
......@@ -46,7 +46,7 @@ use turbopack_core::{
module::Module,
module_graph::{
ModuleGraph, SingleModuleGraph,
binding_usage_info::compute_binding_usage_info,
binding_usage_info::{compute_binding_usage_info, get_unused_references},
chunk_group_info::{ChunkGroup, ChunkGroupEntry},
},
output::{OutputAsset, OutputAssets, OutputAssetsReference, OutputAssetsWithReferenced},
......@@ -497,24 +497,16 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
)
.minify_type(options.minify_type)
.module_merging(options.scope_hoisting)
.export_usage(if options.remove_unused_exports {
Some(binding_usage.unwrap().connect().to_resolved().await?)
} else {
None
})
.debug_ids(options.enable_debug_ids)
.source_map_source_type(options.source_map_source_type)
.chunk_loading_global(options.chunk_loading_global.into());
if options.remove_unused_exports {
builder = builder.export_usage(binding_usage.unwrap());
}
if options.remove_unused_imports {
builder = builder.unused_references(
binding_usage
.unwrap()
.connect()
.unused_references()
.to_resolved()
.await?,
);
builder = builder.unused_references(get_unused_references(binding_usage.unwrap()));
}
if options.production_chunking {
......@@ -545,23 +537,15 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
)
.minify_type(options.minify_type)
.module_merging(options.scope_hoisting)
.export_usage(if options.remove_unused_exports {
Some(binding_usage.unwrap().connect().to_resolved().await?)
} else {
None
})
.debug_ids(options.enable_debug_ids)
.source_map_source_type(options.source_map_source_type);
if options.remove_unused_exports {
builder = builder.export_usage(binding_usage.unwrap());
}
if options.remove_unused_imports {
builder = builder.unused_references(
binding_usage
.unwrap()
.connect()
.unused_references()
.to_resolved()
.await?,
);
builder = builder.unused_references(get_unused_references(binding_usage.unwrap()));
}
if options.production_chunking {
......
......@@ -3,7 +3,7 @@ use rustc_hash::FxHashMap;
use smallvec::SmallVec;
use tracing::Instrument;
use turbo_rcstr::RcStr;
use turbo_tasks::{ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc};
use turbo_tasks::{OperationVc, ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc};
use turbo_tasks_hash::hash_xxh3_hash64;
use turbopack_core::{
chunk::{
......@@ -16,13 +16,13 @@ use turbopack_core::{
};
use turbopack_ecmascript::async_chunk::module::AsyncLoaderModule;
#[turbo_tasks::function]
#[turbo_tasks::function(operation)]
pub async fn get_global_module_id_strategy(
module_graph: ResolvedVc<ModuleGraph>,
module_graph: OperationVc<ModuleGraph>,
) -> Result<Vc<ModuleIdStrategy>> {
let span = tracing::info_span!("compute module id map");
async move {
let module_graph = module_graph.await?;
let module_graph = module_graph.connect().await?;
let graphs = &module_graph.graphs;
// All modules in the graph
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment