Merge export and import usage info

Author: mischnic

crates/next-api/src/analyze.rs

@@ -416,13 +416,15 @@ pub async fn analyze_module_graphs(module_graphs: Vc<ModuleGraphs>) -> Result<Vc
     let mut all_async_edges = FxIndexSet::default();
     for &module_graph in module_graphs.await? {
         let module_graph = module_graph.read_graphs().await?;
-        module_graph.traverse_all_edges_unordered(|(parent_node, reference, _), node| {
-            match reference.chunking_type {
-                ChunkingType::Async => {
-                    all_async_edges.insert((parent_node, node));
-                }
-                _ => {
-                    all_edges.insert((parent_node, node));
+        module_graph.traverse_all_edges_unordered(|parent, node| {
+            if let Some((parent_node, reference, _)) = parent {
+                match reference.chunking_type {
+                    ChunkingType::Async => {
+                        all_async_edges.insert((parent_node, node));
+                    }
+                    _ => {
+                        all_edges.insert((parent_node, node));
+                    }
                 }
             }
             Ok(())

crates/next-api/src/module_graph.rs

@@ -101,7 +101,7 @@ impl NextDynamicGraph {
                 &mut (),
                 |parent_info, node, _| {
                     let module = node;
-                    let Some((parent_node, _)) = parent_info else {
+                    let Some((parent_node, _, _)) = parent_info else {
                         state_map.insert(module, VisitState::Entry);
                         return Ok(GraphTraversalAction::Continue);
                     };
@@ -544,7 +544,7 @@ async fn validate_pages_css_imports(
 
             // If we're at a root node, there is nothing importing this module and we can skip
             // any further validations.
-            let Some((parent_node, _)) = parent_info else {
+            let Some((parent_node, _, _)) = parent_info else {
                 return Ok(GraphTraversalAction::Continue);
             };
             let parent_module = parent_node;

crates/next-api/src/project.rs

@@ -64,8 +64,8 @@ use turbopack_core::{
     module::Module,
     module_graph::{
         GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules,
+        binding_usage_info::{OptionBindingUsageInfo, compute_binding_usage_info},
         chunk_group_info::ChunkGroupEntry,
-        export_usage::{OptionExportUsageInfo, compute_export_usage_info},
     },
     output::{OutputAsset, OutputAssets},
     resolve::{FindContextFileResult, find_context_file},
@@ -1869,15 +1869,35 @@ impl Project {
 
     /// Compute the used exports for each module.
     #[turbo_tasks::function]
-    pub async fn export_usage(self: Vc<Self>) -> Result<Vc<OptionExportUsageInfo>> {
+    pub async fn export_usage(self: Vc<Self>) -> Result<Vc<OptionBindingUsageInfo>> {
         if *self
             .next_config()
             .turbopack_remove_unused_exports(self.next_mode())
             .await?
         {
             let module_graphs = self.whole_app_module_graphs().await?;
             Ok(Vc::cell(Some(
-                compute_export_usage_info(module_graphs.full)
+                compute_binding_usage_info(module_graphs.full)
+                    // As a performance optimization, we resolve strongly consistently
+                    .resolve_strongly_consistent()
+                    .await?,
+            )))
+        } else {
+            Ok(Vc::cell(None))
+        }
+    }
+
+    /// Compute the used exports for each module.
+    #[turbo_tasks::function]
+    pub async fn unused_references(self: Vc<Self>) -> Result<Vc<OptionBindingUsageInfo>> {
+        if *self
+            .next_config()
+            .turbopack_remove_unused_imports(self.next_mode())
+            .await?
+        {
+            let module_graphs = self.whole_app_module_graphs().await?;
+            Ok(Vc::cell(Some(
+                compute_binding_usage_info(module_graphs.full)
                     // As a performance optimization, we resolve strongly consistently
                     .resolve_strongly_consistent()
                     .await?,

crates/next-api/src/webpack_stats.rs

@@ -58,12 +58,14 @@ where
     let asset_reasons = {
         let module_graph = module_graph.read_graphs().await?;
         let mut edges = vec![];
-        module_graph.traverse_all_edges_unordered(|(parent_node, r, _), current| {
-            edges.push((
-                parent_node,
-                RcStr::from(format!("{}: {}", r.chunking_type, r.export)),
-                current,
-            ));
+        module_graph.traverse_all_edges_unordered(|parent, current| {
+            if let Some((parent_node, r, _)) = parent {
+                edges.push((
+                    parent_node,
+                    RcStr::from(format!("{}: {}", r.chunking_type, r.export)),
+                    current,
+                ));
+            }
             Ok(())
         })?;
 

crates/next-core/src/next_client/context.rs

@@ -25,7 +25,7 @@ use turbopack_core::{
     compile_time_info::{CompileTimeDefines, CompileTimeInfo, FreeVarReference, FreeVarReferences},
     environment::{BrowserEnvironment, Environment, ExecutionEnvironment},
     free_var_references,
-    module_graph::export_usage::OptionExportUsageInfo,
+    module_graph::binding_usage_info::OptionBindingUsageInfo,
     resolve::{parse::Request, pattern::Pattern},
 };
 use turbopack_ecmascript::{AnalyzeMode, TypeofWindow, chunk::EcmascriptChunkType};
@@ -421,7 +421,7 @@ pub struct ClientChunkingContextOptions {
     pub chunk_suffix_path: Vc<Option<RcStr>>,
     pub environment: Vc<Environment>,
     pub module_id_strategy: Vc<Box<dyn ModuleIdStrategy>>,
-    pub export_usage: Vc<OptionExportUsageInfo>,
+    pub export_usage: Vc<OptionBindingUsageInfo>,
     pub minify: Vc<bool>,
     pub source_maps: Vc<bool>,
     pub no_mangling: Vc<bool>,

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

@@ -15,7 +15,7 @@ use turbopack_core::{
     context::AssetContext,
     ident::AssetIdent,
     module::Module,
-    module_graph::{ModuleGraph, export_usage::ModuleExportUsageInfo},
+    module_graph::{ModuleGraph, binding_usage_info::ModuleExportUsageInfo},
     reference::{ModuleReference, ModuleReferences},
     reference_type::ReferenceType,
     resolve::ModuleResolveResult,

crates/next-core/src/next_edge/context.rs

@@ -13,7 +13,7 @@ use turbopack_core::{
     compile_time_info::{CompileTimeDefines, CompileTimeInfo, FreeVarReference, FreeVarReferences},
     environment::{EdgeWorkerEnvironment, Environment, ExecutionEnvironment, NodeJsVersion},
     free_var_references,
-    module_graph::export_usage::OptionExportUsageInfo,
+    module_graph::binding_usage_info::OptionBindingUsageInfo,
 };
 use turbopack_ecmascript::chunk::EcmascriptChunkType;
 use turbopack_node::execution_context::ExecutionContext;
@@ -203,7 +203,7 @@ pub struct EdgeChunkingContextOptions {
     pub output_root_to_root_path: Vc<RcStr>,
     pub environment: Vc<Environment>,
     pub module_id_strategy: Vc<Box<dyn ModuleIdStrategy>>,
-    pub export_usage: Vc<OptionExportUsageInfo>,
+    pub export_usage: Vc<OptionBindingUsageInfo>,
     pub turbo_minify: Vc<bool>,
     pub turbo_source_maps: Vc<bool>,
     pub no_mangling: Vc<bool>,

crates/next-core/src/next_server/context.rs

@@ -23,7 +23,7 @@ use turbopack_core::{
     compile_time_info::{CompileTimeDefines, CompileTimeInfo, FreeVarReferences},
     environment::{Environment, ExecutionEnvironment, NodeJsEnvironment, NodeJsVersion},
     free_var_references,
-    module_graph::export_usage::OptionExportUsageInfo,
+    module_graph::binding_usage_info::OptionBindingUsageInfo,
     target::CompileTarget,
 };
 use turbopack_ecmascript::{
@@ -995,7 +995,7 @@ pub struct ServerChunkingContextOptions {
     pub node_root_to_root_path: RcStr,
     pub environment: Vc<Environment>,
     pub module_id_strategy: Vc<Box<dyn ModuleIdStrategy>>,
-    pub export_usage: Vc<OptionExportUsageInfo>,
+    pub export_usage: Vc<OptionBindingUsageInfo>,
     pub turbo_minify: Vc<bool>,
     pub turbo_source_maps: Vc<bool>,
     pub no_mangling: Vc<bool>,

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -23,9 +23,8 @@ use turbopack_core::{
     module::Module,
     module_graph::{
         ModuleGraph,
+        binding_usage_info::{BindingUsageInfo, ModuleExportUsage},
         chunk_group_info::ChunkGroup,
-        export_usage::{ExportUsageInfo, ModuleExportUsage},
-        import_usage::UnusedReferences,
     },
     output::{OutputAsset, OutputAssets},
     reference::ModuleReference,
@@ -165,14 +164,14 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
-    pub fn export_usage(mut self, export_usage: Option<ResolvedVc<ExportUsageInfo>>) -> Self {
+    pub fn export_usage(mut self, export_usage: Option<ResolvedVc<BindingUsageInfo>>) -> Self {
         self.chunking_context.export_usage = export_usage;
         self
     }
 
     pub fn unused_references(
         mut self,
-        unused_references: Option<ResolvedVc<UnusedReferences>>,
+        unused_references: Option<ResolvedVc<BindingUsageInfo>>,
     ) -> Self {
         self.chunking_context.unused_references = unused_references;
         self
@@ -294,9 +293,9 @@ pub struct BrowserChunkingContext {
     /// The module id strategy to use
     module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
     /// The module export usage info, if available.
-    export_usage: Option<ResolvedVc<ExportUsageInfo>>,
+    export_usage: Option<ResolvedVc<BindingUsageInfo>>,
     /// Which references are unused and should be skipped (e.g. during codegen).
-    unused_references: Option<ResolvedVc<UnusedReferences>>,
+    unused_references: Option<ResolvedVc<BindingUsageInfo>>,
     /// 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")`)
@@ -872,8 +871,6 @@ impl ChunkingContext for BrowserChunkingContext {
         if let Some(export_usage) = self.await?.export_usage {
             Ok(export_usage.await?.used_exports(module).await?)
         } else {
-            // In development mode, we don't have export usage info, so we assume all exports are
-            // used.
             Ok(ModuleExportUsage::all())
         }
     }
@@ -885,7 +882,7 @@ impl ChunkingContext for BrowserChunkingContext {
     ) -> Result<Vc<bool>> {
         if let Some(unused_references) = self.await?.unused_references {
             Ok(Vc::cell(
-                unused_references.await?.contains_reference(&reference),
+                unused_references.await?.is_reference_unused(&reference),
             ))
         } else {
             Ok(Vc::cell(false))

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -33,8 +33,8 @@ use turbopack_core::{
     module::Module,
     module_graph::{
         ModuleGraph,
+        binding_usage_info::compute_binding_usage_info,
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
-        export_usage::compute_export_usage_info,
     },
     output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
     reference::all_assets_from_entries,
@@ -306,7 +306,7 @@ async fn build_internal(
     .instrument(tracing::info_span!("resolve entries"))
     .await?;
 
-    let module_graph = ModuleGraph::from_modules(
+    let mut module_graph = ModuleGraph::from_modules(
         Vc::cell(vec![ChunkGroupEntry::Entry(entries.clone())]),
         false,
     );
@@ -315,9 +315,10 @@ async fn build_internal(
             .to_resolved()
             .await?,
     );
-    let export_usage = compute_export_usage_info(module_graph.to_resolved().await?)
+    let binding_usage = compute_binding_usage_info(module_graph.to_resolved().await?)
         .resolve_strongly_consistent()
         .await?;
+    module_graph = module_graph.without_unused_references(*binding_usage);
 
     let chunking_context: Vc<Box<dyn ChunkingContext>> = match target {
         Target::Browser => {
@@ -343,7 +344,8 @@ async fn build_internal(
             )
             .source_maps(source_maps_type)
             .module_id_strategy(module_id_strategy)
-            .export_usage(Some(export_usage))
+            .export_usage(Some(binding_usage))
+            .unused_references(Some(binding_usage))
             .current_chunk_method(CurrentChunkMethod::DocumentCurrentScript)
             .minify_type(minify_type);
 
@@ -391,7 +393,8 @@ async fn build_internal(
             )
             .source_maps(source_maps_type)
             .module_id_strategy(module_id_strategy)
-            .export_usage(Some(export_usage))
+            .export_usage(Some(binding_usage))
+            .unused_references(Some(binding_usage))
             .minify_type(minify_type);
 
             match *node_env.await? {