unify into BindingUsage

Author: mischnic

crates/next-core/src/next_client_reference/visit_client_reference.rs

@@ -192,9 +192,9 @@ impl Visit<FindServerEntriesNode> for FindServerEntries {
 
             let referenced_modules = referenced_modules
                 .iter()
-                .flat_map(|(_, chunking_type, _, _, modules)| match chunking_type {
+                .flat_map(|(_, resolved)| match resolved.chunking_type {
                     ChunkingType::Traced => None,
-                    _ => Some(modules.iter()),
+                    _ => Some(resolved.modules.iter()),
                 })
                 .flatten()
                 .map(async |module| {

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

@@ -46,7 +46,7 @@ use crate::{
     },
     output::OutputAssets,
     reference::ModuleReference,
-    resolve::{ExportUsage, ImportUsage},
+    resolve::BindingUsage,
 };
 
 /// A module id, which can be a number or string
@@ -422,13 +422,8 @@ pub trait ChunkableModuleReference: ModuleReference + ValueToString {
     }
 
     #[turbo_tasks::function]
-    fn export_usage(self: Vc<Self>) -> Vc<ExportUsage> {
-        ExportUsage::all()
-    }
-
-    #[turbo_tasks::function]
-    fn import_usage(self: Vc<Self>) -> Vc<ImportUsage> {
-        ImportUsage::global()
+    fn binding_usage(self: Vc<Self>) -> Vc<BindingUsage> {
+        BindingUsage::all()
     }
 }
 

turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs

@@ -109,7 +109,7 @@ pub async fn compute_binding_usage_info(
 
             if remove_unused_imports {
                 // If the current edge is an unused import, skip it
-                match &ref_data.import {
+                match &ref_data.binding_usage.import {
                     ImportUsage::Exports(exports) => {
                         let source_used_exports = used_exports.get(&parent).unwrap();
                         if exports
@@ -118,7 +118,7 @@ pub async fn compute_binding_usage_info(
                         {
                             debug_unused_references_name.insert((
                                 parent,
-                                ref_data.export.clone(),
+                                ref_data.binding_usage.export.clone(),
                                 target,
                             ));
                             unused_references_edges.insert(edge);
@@ -128,7 +128,7 @@ pub async fn compute_binding_usage_info(
                         } else {
                             debug_unused_references_name.remove(&(
                                 parent,
-                                ref_data.export.clone(),
+                                ref_data.binding_usage.export.clone(),
                                 target,
                             ));
                             unused_references_edges.remove(&edge);
@@ -139,7 +139,7 @@ pub async fn compute_binding_usage_info(
                     ImportUsage::Global => {
                         debug_unused_references_name.remove(&(
                             parent,
-                            ref_data.export.clone(),
+                            ref_data.binding_usage.export.clone(),
                             target,
                         ));
                         unused_references_edges.remove(&edge);
@@ -151,7 +151,7 @@ pub async fn compute_binding_usage_info(
 
             let entry = used_exports.entry(target);
             let is_first_visit = matches!(entry, Entry::Vacant(_));
-            if entry.or_default().add(&ref_data.export) || is_first_visit {
+            if entry.or_default().add(&ref_data.binding_usage.export) || is_first_visit {
                 // First visit, or the used exports changed. This can cause more imports to get used
                 // downstream.
                 Ok(GraphTraversalAction::Continue)

turbopack/crates/turbopack-core/src/module_graph/merged_modules.rs

@@ -491,7 +491,9 @@ pub async fn compute_merged_modules(module_graph: Vc<ModuleGraph>) -> Result<Vc<
                     // necessarily needed for browser),
                     exposed_modules_imported.insert(module);
                 }
-                if parent_info.is_some_and(|(_, r)| matches!(r.export, ExportUsage::All)) {
+                if parent_info
+                    .is_some_and(|(_, r)| matches!(r.binding_usage.export, ExportUsage::All))
+                {
                     // This module needs to be exposed:
                     // - namespace import from another group
                     exposed_modules_namespace.insert(module);

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

@@ -37,7 +37,7 @@ use crate::{
         traced_di_graph::TracedDiGraph,
     },
     reference::{ModuleReference, primary_chunkable_referenced_modules},
-    resolve::{ExportUsage, ImportUsage},
+    resolve::BindingUsage,
 };
 
 pub mod async_module_info;
@@ -225,8 +225,7 @@ pub struct SingleModuleGraph {
 )]
 pub struct RefData {
     pub chunking_type: ChunkingType,
-    pub export: ExportUsage,
-    pub import: ImportUsage,
+    pub binding_usage: BindingUsage,
     pub reference: ResolvedVc<Box<dyn ModuleReference>>,
 }
 
@@ -246,16 +245,15 @@ impl SingleModuleGraph {
             .map(|e| async move {
                 Ok(SingleModuleGraphBuilderEdge {
                     to: SingleModuleGraphBuilderNode::new_module(emit_spans, e).await?,
-                    export: ExportUsage::All,
-                    import: ImportUsage::Global,
+                    binding_usage: BindingUsage::default(),
                     reference: None,
                 })
             })
             .try_join()
             .await?;
 
         let (children_nodes_iter, visited_nodes) = AdjacencyMap::new()
-            .skip_duplicates_with_key(|node: &(SingleModuleGraphBuilderNode, _, _, _)| &node.0)
+            .skip_duplicates_with_key(|node: &(SingleModuleGraphBuilderNode, _, _)| &node.0)
             .visit(
                 root_edges,
                 SingleModuleGraphBuilder {
@@ -282,16 +280,15 @@ impl SingleModuleGraph {
             FxHashMap::with_capacity_and_hasher(node_count, Default::default());
         {
             let _span = tracing::info_span!("build module graph").entered();
-            for (parent, (current, reference, export, import)) in
+            for (parent, (current, reference, binding_usage)) in
                 children_nodes_iter.into_breadth_first_edges()
             {
                 let parent_edge = match parent.map(|v| v.0) {
                     Some(SingleModuleGraphBuilderNode::Module { module, .. }) => Some((
                         *modules.get(&module).unwrap(),
                         RefData {
                             chunking_type: COMMON_CHUNKING_TYPE,
-                            export,
-                            import,
+                            binding_usage,
                             reference: reference.unwrap(),
                         },
                     )),
@@ -1562,8 +1559,7 @@ impl SingleModuleGraphBuilderNode {
 }
 struct SingleModuleGraphBuilderEdge {
     to: SingleModuleGraphBuilderNode,
-    export: ExportUsage,
-    import: ImportUsage,
+    binding_usage: BindingUsage,
     reference: Option<ResolvedVc<Box<dyn ModuleReference>>>,
 }
 
@@ -1586,8 +1582,7 @@ impl
     Visit<(
         SingleModuleGraphBuilderNode,
         Option<ResolvedVc<Box<dyn ModuleReference>>>,
-        ExportUsage,
-        ImportUsage,
+        BindingUsage,
     )> for SingleModuleGraphBuilder<'_>
 {
     type Edge = SingleModuleGraphBuilderEdge;
@@ -1600,29 +1595,23 @@ impl
     ) -> VisitControlFlow<(
         SingleModuleGraphBuilderNode,
         Option<ResolvedVc<Box<dyn ModuleReference>>>,
-        ExportUsage,
-        ImportUsage,
+        BindingUsage,
     )> {
         match edge.to {
             SingleModuleGraphBuilderNode::Module { .. } => {
-                VisitControlFlow::Continue((edge.to, edge.reference, edge.export, edge.import))
+                VisitControlFlow::Continue((edge.to, edge.reference, edge.binding_usage))
             }
             SingleModuleGraphBuilderNode::ChunkableReference { ref ref_data, .. } => {
                 match &ref_data.chunking_type {
                     ChunkingType::Traced => {
-                        VisitControlFlow::Skip((edge.to, edge.reference, edge.export, edge.import))
+                        VisitControlFlow::Skip((edge.to, edge.reference, edge.binding_usage))
                     }
-                    _ => VisitControlFlow::Continue((
-                        edge.to,
-                        edge.reference,
-                        edge.export,
-                        edge.import,
-                    )),
+                    _ => VisitControlFlow::Continue((edge.to, edge.reference, edge.binding_usage)),
                 }
             }
             // Module was already visited previously
             SingleModuleGraphBuilderNode::VisitedModule { .. } => {
-                VisitControlFlow::Skip((edge.to, edge.reference, edge.export, edge.import))
+                VisitControlFlow::Skip((edge.to, edge.reference, edge.binding_usage))
             }
         }
     }
@@ -1634,8 +1623,7 @@ impl
         (node, ..): &(
             SingleModuleGraphBuilderNode,
             Option<ResolvedVc<Box<dyn ModuleReference>>>,
-            ExportUsage,
-            ImportUsage,
+            BindingUsage,
         ),
     ) -> Self::EdgesFuture {
         // Destructure beforehand to not have to clone the whole node when entering the async block
@@ -1645,12 +1633,7 @@ impl
                 target, ref_data, ..
             } => (
                 None,
-                Some((
-                    *target,
-                    ref_data.reference,
-                    ref_data.export.clone(),
-                    ref_data.import.clone(),
-                )),
+                Some((*target, ref_data.reference, ref_data.binding_usage.clone())),
             ),
             // These are always skipped in `visit()`
             SingleModuleGraphBuilderNode::VisitedModule { .. } => unreachable!(),
@@ -1670,12 +1653,17 @@ impl
                     };
 
                     refs.iter()
-                        .flat_map(|(reference, ty, export, import, modules)| {
-                            modules.iter().map(|m| {
-                                (*reference, ty.clone(), export.clone(), import.clone(), *m)
+                        .flat_map(|(reference, resolved)| {
+                            resolved.modules.iter().map(|m| {
+                                (
+                                    *reference,
+                                    resolved.chunking_type.clone(),
+                                    resolved.binding_usage.clone(),
+                                    *m,
+                                )
                             })
                         })
-                        .map(async |(reference, ty, export, import, target)| {
+                        .map(async |(reference, ty, binding_usage, target)| {
                             let to = if ty == COMMON_CHUNKING_TYPE {
                                 if let Some(idx) = visited_modules.get(&target) {
                                     SingleModuleGraphBuilderNode::new_visited_module(target, *idx)
@@ -1690,24 +1678,22 @@ impl
                                     target,
                                     RefData {
                                         chunking_type: ty,
-                                        export: export.clone(),
-                                        import: import.clone(),
+                                        binding_usage: binding_usage.clone(),
                                         reference,
                                     },
                                 )
                                 .await?
                             };
                             Ok(SingleModuleGraphBuilderEdge {
                                 to,
-                                export,
-                                import,
+                                binding_usage,
                                 reference: Some(reference),
                             })
                         })
                         .try_join()
                         .await?
                 }
-                (None, Some((chunkable_ref_target, reference, export, import))) => {
+                (None, Some((chunkable_ref_target, reference, binding_usage))) => {
                     vec![SingleModuleGraphBuilderEdge {
                         to: if let Some(idx) = visited_modules.get(&chunkable_ref_target) {
                             SingleModuleGraphBuilderNode::new_visited_module(
@@ -1721,8 +1707,7 @@ impl
                             )
                             .await?
                         },
-                        export,
-                        import,
+                        binding_usage,
                         reference: Some(reference),
                     }]
                 }
@@ -1736,8 +1721,7 @@ impl
         (node, ..): &(
             SingleModuleGraphBuilderNode,
             Option<ResolvedVc<Box<dyn ModuleReference>>>,
-            ExportUsage,
-            ImportUsage,
+            BindingUsage,
         ),
     ) -> tracing::Span {
         if !self.emit_spans {

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

@@ -1,18 +1,22 @@
 use std::collections::HashSet;
 
 use anyhow::Result;
+use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
 use turbo_tasks::{
-    FxIndexSet, ReadRef, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, ValueToString, Vc,
+    FxIndexSet, NonLocalValue, ReadRef, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt,
+    ValueToString, Vc,
+    debug::ValueDebugFormat,
     graph::{AdjacencyMap, GraphTraversal},
+    trace::TraceRawVcs,
 };
 
 use crate::{
     chunk::{ChunkableModuleReference, ChunkingType, ChunkingTypeOption},
     module::{Module, Modules},
     output::{OutputAsset, OutputAssets},
     raw_module::RawModule,
-    resolve::{ExportUsage, ImportUsage, ModuleResolveResult, RequestKey},
+    resolve::{BindingUsage, ExportUsage, ImportUsage, ModuleResolveResult, RequestKey},
 };
 pub mod source_map;
 
@@ -119,8 +123,12 @@ impl ChunkableModuleReference for SingleChunkableModuleReference {
     }
 
     #[turbo_tasks::function]
-    fn export_usage(&self) -> Vc<ExportUsage> {
-        *self.export
+    async fn binding_usage(&self) -> Result<Vc<BindingUsage>> {
+        Ok(BindingUsage {
+            import: ImportUsage::Global,
+            export: self.export.owned().await?,
+        }
+        .cell())
     }
 }
 
@@ -285,16 +293,17 @@ pub async fn primary_referenced_modules(module: Vc<Box<dyn Module>>) -> Result<V
     Ok(Vc::cell(modules))
 }
 
+#[derive(
+    Clone, Serialize, Deserialize, Eq, PartialEq, ValueDebugFormat, TraceRawVcs, NonLocalValue,
+)]
+pub struct ResolvedReference {
+    pub chunking_type: ChunkingType,
+    pub binding_usage: BindingUsage,
+    pub modules: ReadRef<Modules>,
+}
+
 #[turbo_tasks::value(transparent)]
-pub struct ModulesWithRefData(
-    Vec<(
-        ResolvedVc<Box<dyn ModuleReference>>,
-        ChunkingType,
-        ExportUsage,
-        ImportUsage,
-        ReadRef<Modules>,
-    )>,
-);
+pub struct ModulesWithRefData(Vec<(ResolvedVc<Box<dyn ModuleReference>>, ResolvedReference)>);
 
 /// Aggregates all primary [Module]s referenced by an [Module] via [ChunkableModuleReference]s.
 /// This does not include transitively referenced [Module]s, only includes
@@ -325,15 +334,15 @@ pub async fn primary_chunkable_referenced_modules(
                     .await?
                     .primary_modules()
                     .await?;
-                let export = reference.export_usage().owned().await?;
-                let import = reference.import_usage().owned().await?;
+                let binding_usage = reference.binding_usage().owned().await?;
 
                 return Ok(Some((
                     ResolvedVc::upcast(reference),
-                    chunking_type.clone(),
-                    export,
-                    import,
-                    resolved,
+                    ResolvedReference {
+                        chunking_type: chunking_type.clone(),
+                        binding_usage,
+                        modules: resolved,
+                    },
                 )));
             }
             Ok(None)