chunking_context.is_reference_unused

Author: mischnic

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

@@ -25,8 +25,10 @@ use turbopack_core::{
         ModuleGraph,
         chunk_group_info::ChunkGroup,
         export_usage::{ExportUsageInfo, ModuleExportUsage},
+        import_usage::UnusedReferences,
     },
     output::{OutputAsset, OutputAssets},
+    reference::ModuleReference,
 };
 use turbopack_ecmascript::{
     async_chunk::module::AsyncLoaderModule,
@@ -168,6 +170,14 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
+    pub fn unused_references(
+        mut self,
+        unused_references: Option<ResolvedVc<UnusedReferences>>,
+    ) -> Self {
+        self.chunking_context.unused_references = unused_references;
+        self
+    }
+
     pub fn debug_ids(mut self, debug_ids: bool) -> Self {
         self.chunking_context.debug_ids = debug_ids;
         self
@@ -285,6 +295,8 @@ pub struct BrowserChunkingContext {
     module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
     /// The module export usage info, if available.
     export_usage: Option<ResolvedVc<ExportUsageInfo>>,
+    /// Which references are unused and should be skipped (e.g. during codegen).
+    unused_references: Option<ResolvedVc<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")`)
@@ -332,6 +344,7 @@ impl BrowserChunkingContext {
                 manifest_chunks: false,
                 module_id_strategy: ResolvedVc::upcast(DevModuleIdStrategy::new_resolved()),
                 export_usage: None,
+                unused_references: None,
                 chunking_configs: Default::default(),
                 should_use_absolute_url_references: false,
             },
@@ -865,6 +878,20 @@ impl ChunkingContext for BrowserChunkingContext {
         }
     }
 
+    #[turbo_tasks::function]
+    async fn is_reference_unused(
+        self: Vc<Self>,
+        reference: ResolvedVc<Box<dyn ModuleReference>>,
+    ) -> Result<Vc<bool>> {
+        if let Some(unused_references) = self.await?.unused_references {
+            Ok(Vc::cell(
+                unused_references.await?.contains_reference(&reference),
+            ))
+        } else {
+            Ok(Vc::cell(false))
+        }
+    }
+
     #[turbo_tasks::function]
     async fn debug_ids_enabled(self: Vc<Self>) -> Result<Vc<bool>> {
         Ok(Vc::cell(self.await?.debug_ids))

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

@@ -18,6 +18,7 @@ use crate::{
         module_batches::BatchingConfig,
     },
     output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
+    reference::ModuleReference,
 };
 
 #[derive(
@@ -317,6 +318,12 @@ pub trait ChunkingContext {
         module: Vc<Box<dyn Module>>,
     ) -> Result<Vc<ModuleExportUsage>>;
 
+    #[turbo_tasks::function]
+    async fn is_reference_unused(
+        self: Vc<Self>,
+        reference: Vc<Box<dyn ModuleReference>>,
+    ) -> Result<Vc<bool>>;
+
     /// Returns whether debug IDs are enabled for this chunking context.
     #[turbo_tasks::function]
     fn debug_ids_enabled(self: Vc<Self>) -> Vc<bool>;

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

@@ -286,7 +286,15 @@ pub async fn primary_referenced_modules(module: Vc<Box<dyn Module>>) -> Result<V
 }
 
 #[turbo_tasks::value(transparent)]
-pub struct ModulesWithRefData(Vec<(ChunkingType, ExportUsage, ImportUsage, ReadRef<Modules>)>);
+pub struct ModulesWithRefData(
+    Vec<(
+        ResolvedVc<Box<dyn ModuleReference>>,
+        ChunkingType,
+        ExportUsage,
+        ImportUsage,
+        ReadRef<Modules>,
+    )>,
+);
 
 /// Aggregates all primary [Module]s referenced by an [Module] via [ChunkableModuleReference]s.
 /// This does not include transitively referenced [Module]s, only includes
@@ -320,7 +328,13 @@ pub async fn primary_chunkable_referenced_modules(
                 let export = reference.export_usage().owned().await?;
                 let import = reference.import_usage().owned().await?;
 
-                return Ok(Some((chunking_type.clone(), export, import, resolved)));
+                return Ok(Some((
+                    ResolvedVc::upcast(reference),
+                    chunking_type.clone(),
+                    export,
+                    import,
+                    resolved,
+                )));
             }
             Ok(None)
         })

turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs

@@ -534,6 +534,13 @@ impl EsmAssetReference {
     ) -> Result<CodeGeneration> {
         let this = &*self.await?;
 
+        if *chunking_context
+            .is_reference_unused(Vc::upcast(self))
+            .await?
+        {
+            return Ok(CodeGeneration::empty());
+        }
+
         // only chunked references can be imported
         if this.annotations.chunking_type() != Some("none") {
             let import_externals = this.import_externals;

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

@@ -20,8 +20,10 @@ use turbopack_core::{
         ModuleGraph,
         chunk_group_info::ChunkGroup,
         export_usage::{ExportUsageInfo, ModuleExportUsage},
+        import_usage::UnusedReferences,
     },
     output::{OutputAsset, OutputAssets},
+    reference::ModuleReference,
 };
 use turbopack_ecmascript::{
     async_chunk::module::AsyncLoaderModule,
@@ -117,6 +119,14 @@ impl NodeJsChunkingContextBuilder {
         self
     }
 
+    pub fn unused_references(
+        mut self,
+        unused_references: Option<ResolvedVc<UnusedReferences>>,
+    ) -> Self {
+        self.chunking_context.unused_references = unused_references;
+        self
+    }
+
     pub fn chunking_config<T>(mut self, ty: ResolvedVc<T>, chunking_config: ChunkingConfig) -> Self
     where
         T: Upcast<Box<dyn ChunkType>>,
@@ -182,6 +192,8 @@ pub struct NodeJsChunkingContext {
     module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
     /// The module export usage info, if available.
     export_usage: Option<ResolvedVc<ExportUsageInfo>>,
+    /// Which references are unused and should be skipped (e.g. during codegen).
+    unused_references: Option<ResolvedVc<UnusedReferences>>,
     /// The strategy to use for generating source map source uris
     source_map_source_type: SourceMapSourceType,
     /// The chunking configs
@@ -225,6 +237,7 @@ impl NodeJsChunkingContext {
                 source_map_source_type: SourceMapSourceType::TurbopackUri,
                 module_id_strategy: ResolvedVc::upcast(DevModuleIdStrategy::new_resolved()),
                 export_usage: None,
+                unused_references: None,
                 chunking_configs: Default::default(),
                 debug_ids: false,
             },
@@ -600,6 +613,20 @@ impl ChunkingContext for NodeJsChunkingContext {
         }
     }
 
+    #[turbo_tasks::function]
+    async fn is_reference_unused(
+        self: Vc<Self>,
+        reference: ResolvedVc<Box<dyn ModuleReference>>,
+    ) -> Result<Vc<bool>> {
+        if let Some(unused_references) = self.await?.unused_references {
+            Ok(Vc::cell(
+                unused_references.await?.contains_reference(&reference),
+            ))
+        } else {
+            Ok(Vc::cell(false))
+        }
+    }
+
     #[turbo_tasks::function]
     fn debug_ids_enabled(&self) -> Vc<bool> {
         Vc::cell(self.debug_ids)

turbopack/crates/turbopack-tests/tests/execution.rs

@@ -39,7 +39,10 @@ use turbopack_core::{
     file_source::FileSource,
     ident::Layer,
     issue::CollectibleIssuesExt,
-    module_graph::{ModuleGraph, export_usage::compute_export_usage_info},
+    module_graph::{
+        ModuleGraph, export_usage::compute_export_usage_info,
+        import_usage::compute_import_usage_info,
+    },
     reference_type::{InnerAssets, ReferenceType},
     resolve::{
         ExternalTraced, ExternalType,
@@ -474,9 +477,15 @@ async fn run_test_operation(prepared_test: ResolvedVc<PreparedTest>) -> Result<V
 
     let mut module_graph = ModuleGraph::from_modules(entries.graph_entries(), false);
 
-    if options.remove_unused_imports {
-        module_graph = module_graph.without_unused_references();
-    }
+    let unused_references = if options.remove_unused_imports {
+        let unused_references = compute_import_usage_info(module_graph.to_resolved().await?)
+            .resolve_strongly_consistent()
+            .await?;
+        module_graph = module_graph.without_unused_references(*unused_references);
+        Some(unused_references)
+    } else {
+        None
+    };
 
     let chunking_context = NodeJsChunkingContext::builder(
         project_root.clone(),

turbopack/crates/turbopack-tests/tests/snapshot.rs

@@ -49,6 +49,7 @@ use turbopack_core::{
         ModuleGraph,
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
         export_usage::compute_export_usage_info,
+        import_usage::compute_import_usage_info,
     },
     output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
     reference_type::{EntryReferenceSubType, ReferenceType},
@@ -432,9 +433,16 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
         Vc::cell(vec![ChunkGroupEntry::Entry(entry_modules.clone())]),
         false,
     );
-    if options.remove_unused_imports {
-        module_graph = module_graph.without_unused_references();
-    }
+
+    let unused_references = if options.remove_unused_imports {
+        let unused_references = compute_import_usage_info(module_graph.to_resolved().await?)
+            .resolve_strongly_consistent()
+            .await?;
+        module_graph = module_graph.without_unused_references(*unused_references);
+        Some(unused_references)
+    } else {
+        None
+    };
 
     let export_usage = if options.remove_unused_exports {
         Some(
@@ -469,6 +477,7 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
             .minify_type(options.minify_type)
             .module_merging(options.scope_hoisting)
             .export_usage(export_usage)
+            .unused_references(unused_references)
             .debug_ids(options.enable_debug_ids)
             .source_map_source_type(options.source_map_source_type);
 
@@ -499,6 +508,7 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
             .minify_type(options.minify_type)
             .module_merging(options.scope_hoisting)
             .export_usage(export_usage)
+            .unused_references(unused_references)
             .debug_ids(options.enable_debug_ids)
             .source_map_source_type(options.source_map_source_type);