Prepare select_part

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

@@ -15,21 +15,23 @@ use swc_core::{
     },
     quote, quote_expr,
 };
-use turbo_tasks::{trace::TraceRawVcs, RcStr, TryFlatJoinIterExt, ValueToString, Vc};
+use turbo_tasks::{trace::TraceRawVcs, vdbg, RcStr, TryFlatJoinIterExt, ValueToString, Vc};
 use turbo_tasks_fs::glob::Glob;
 use turbopack_core::{
     chunk::ChunkingContext,
     ident::AssetIdent,
     issue::{analyze::AnalyzeIssue, IssueExt, IssueSeverity, StyledString},
     module::Module,
     reference::ModuleReference,
+    resolve::ModulePart,
 };
 
 use super::base::ReferencedAsset;
 use crate::{
     chunk::{EcmascriptChunkPlaceable, EcmascriptExports},
     code_gen::{CodeGenerateable, CodeGeneration, CodeGenerationHoistedStmt},
     magic_identifier,
+    tree_shake::asset::EcmascriptModulePartAsset,
 };
 
 #[derive(Clone, Hash, Debug, PartialEq, Eq, Serialize, Deserialize, TraceRawVcs)]
@@ -126,10 +128,12 @@ pub async fn follow_reexports(
     module: Vc<Box<dyn EcmascriptChunkPlaceable>>,
     export_name: RcStr,
     side_effect_free_packages: Vc<Glob>,
+    ignore_side_effect_of_entry: Vc<bool>,
 ) -> Result<Vc<FollowExportsResult>> {
-    if !*module
-        .is_marked_as_side_effect_free(side_effect_free_packages)
-        .await?
+    if !*ignore_side_effect_of_entry.await?
+        && !*module
+            .is_marked_as_side_effect_free(side_effect_free_packages)
+            .await?
     {
         return Ok(FollowExportsResult::cell(FollowExportsResult {
             module,
@@ -140,6 +144,7 @@ pub async fn follow_reexports(
     let mut module = module;
     let mut export_name = export_name;
     loop {
+        vdbg!(&*module.ident().to_string().await?);
         let exports = module.get_exports().await?;
         let EcmascriptExports::EsmExports(exports) = &*exports else {
             return Ok(FollowExportsResult::cell(FollowExportsResult {
@@ -152,13 +157,20 @@ pub async fn follow_reexports(
         // Try to find the export in the local exports
         let exports_ref = exports.await?;
         if let Some(export) = exports_ref.exports.get(&export_name) {
-            match handle_declared_export(module, export_name, export, side_effect_free_packages)
-                .await?
+            match handle_declared_export(
+                module,
+                export_name.clone(),
+                export,
+                side_effect_free_packages,
+            )
+            .await?
             {
                 ControlFlow::Continue((m, n)) => {
-                    module = m;
-                    export_name = n;
-                    continue;
+                    if !is_module_part_with_no_real_export(m).await? {
+                        module = m;
+                        export_name = n;
+                        continue;
+                    }
                 }
                 ControlFlow::Break(result) => {
                     return Ok(result.cell());
@@ -171,6 +183,7 @@ pub async fn follow_reexports(
             let result = get_all_export_names(module).await?;
             if let Some(m) = result.esm_exports.get(&export_name) {
                 module = *m;
+                vdbg!("all_export_names", &*module.ident().to_string().await?);
                 continue;
             }
             return match &result.dynamic_exporting_modules[..] {
@@ -203,6 +216,21 @@ pub async fn follow_reexports(
     }
 }
 
+async fn is_module_part_with_no_real_export(
+    module: Vc<Box<dyn EcmascriptChunkPlaceable>>,
+) -> Result<bool> {
+    if let Some(module) = Vc::try_resolve_downcast_type::<EcmascriptModulePartAsset>(module).await?
+    {
+        if matches!(
+            *module.await?.part.await?,
+            ModulePart::Internal(..) | ModulePart::Evaluation
+        ) {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
 async fn handle_declared_export(
     module: Vc<Box<dyn EcmascriptChunkPlaceable>>,
     export_name: RcStr,

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

@@ -11,7 +11,7 @@ pub use self::{
     base::EsmAssetReference,
     binding::EsmBinding,
     dynamic::EsmAsyncAssetReference,
-    export::{EsmExport, EsmExports},
+    export::{EsmExport, EsmExports, FoundExportType},
     meta::{ImportMetaBinding, ImportMetaRef},
     module_item::EsmModuleItem,
     url::{UrlAssetReference, UrlRewriteBehavior},

turbopack/crates/turbopack-ecmascript/src/tree_shake/asset.rs

@@ -1,12 +1,14 @@
 use anyhow::{Context, Result};
-use turbo_tasks::Vc;
+use turbo_tasks::{vdbg, RcStr, ValueToString, Vc};
+use turbo_tasks_fs::glob::Glob;
 use turbopack_core::{
     asset::{Asset, AssetContent},
     chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, EvaluatableAsset},
+    context::AssetContext,
     ident::AssetIdent,
     module::Module,
     reference::{ModuleReference, ModuleReferences, SingleModuleReference},
-    resolve::ModulePart,
+    resolve::{origin::ResolveOrigin, ModulePart},
 };
 
 use super::{
@@ -16,7 +18,10 @@ use super::{
 use crate::{
     chunk::{EcmascriptChunkPlaceable, EcmascriptExports},
     parse::ParseResult,
-    references::analyse_ecmascript_module,
+    references::{
+        analyse_ecmascript_module, esm::FoundExportType, follow_reexports, FollowExportsResult,
+    },
+    tree_shake::Key,
     AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptModuleAsset,
     EcmascriptModuleAssetType, EcmascriptModuleContent, EcmascriptParsable,
 };
@@ -92,13 +97,66 @@ impl EcmascriptModulePartAsset {
         module: Vc<EcmascriptModuleAsset>,
         part: Vc<ModulePart>,
     ) -> Result<Vc<Box<dyn Module>>> {
-        let split_result = split_module(module).await?;
+        let SplitResult::Ok { entrypoints, .. } = &*split_module(module).await? else {
+            return Ok(Vc::upcast(module));
+        };
 
-        Ok(if matches!(&*split_result, SplitResult::Failed { .. }) {
-            Vc::upcast(module)
-        } else {
-            Vc::upcast(EcmascriptModulePartAsset::new(module, part))
-        })
+        // We follow reexports here
+        if let ModulePart::Export(export) = &*part.await? {
+            let export_name = export.await?.clone_value();
+
+            // If a local binding or reexport with the same name exists, we stop here.
+            // Side effects of the barrel file are preserved.
+            if entrypoints.contains_key(&Key::Export(export_name.clone())) {
+                return Ok(Vc::upcast(EcmascriptModulePartAsset::new(module, part)));
+            }
+
+            let side_effect_free_packages = module.asset_context().side_effect_free_packages();
+
+            // Exclude local bindings by using exports module part.
+            let source_module = if entrypoints.contains_key(&Key::Exports)
+                && *module
+                    .is_marked_as_side_effect_free(side_effect_free_packages)
+                    .await?
+            {
+                Vc::upcast(EcmascriptModulePartAsset::new(
+                    module,
+                    ModulePart::exports(),
+                ))
+            } else {
+                Vc::upcast(module)
+            };
+
+            let FollowExportsWithSideEffectsResult {
+                side_effects,
+                result,
+            } = &*follow_reexports_with_side_effects(
+                source_module,
+                export_name.clone(),
+                side_effect_free_packages,
+            )
+            .await?;
+
+            let FollowExportsResult {
+                module: final_module,
+                export_name: new_export,
+                ty,
+            } = &*result.await?;
+
+            vdbg!(
+                *ty,
+                final_module.ident().to_string().await?,
+                new_export.clone()
+            );
+
+            if let Some(new_export) = new_export {
+                if *new_export == export_name {
+                    return Ok(Vc::upcast(*final_module));
+                }
+            }
+        }
+
+        Ok(Vc::upcast(EcmascriptModulePartAsset::new(module, part)))
     }
 
     #[turbo_tasks::function]
@@ -114,6 +172,58 @@ impl EcmascriptModulePartAsset {
     }
 }
 
+#[turbo_tasks::value]
+struct FollowExportsWithSideEffectsResult {
+    side_effects: Vc<SideEffects>,
+    result: Vc<FollowExportsResult>,
+}
+
+#[turbo_tasks::value(transparent)]
+struct SideEffects(Vec<Vc<Box<dyn EcmascriptChunkPlaceable>>>);
+
+#[turbo_tasks::function]
+async fn follow_reexports_with_side_effects(
+    module: Vc<Box<dyn EcmascriptChunkPlaceable>>,
+    export_name: RcStr,
+    side_effect_free_packages: Vc<Glob>,
+) -> Result<Vc<FollowExportsWithSideEffectsResult>> {
+    let mut side_effects = vec![];
+
+    let mut current_module = module;
+    let mut current_export_name = export_name;
+    let result = loop {
+        // We ignore the side effect of the entry module here, because we need to proceed.
+        let result = follow_reexports(
+            current_module,
+            current_export_name.clone(),
+            side_effect_free_packages,
+            Vc::cell(true),
+        );
+        dbg!(&*current_module.ident().to_string().await?);
+
+        let FollowExportsResult {
+            module,
+            export_name,
+            ty,
+        } = &*result.await?;
+
+        match ty {
+            FoundExportType::SideEffects => {
+                side_effects.push(*module);
+                current_module = *module;
+                current_export_name = export_name.clone().unwrap_or(current_export_name);
+            }
+            _ => break result,
+        }
+    };
+
+    Ok(FollowExportsWithSideEffectsResult {
+        side_effects: Vc::cell(side_effects),
+        result,
+    }
+    .cell())
+}
+
 #[turbo_tasks::value_impl]
 impl Module for EcmascriptModulePartAsset {
     #[turbo_tasks::function]
@@ -200,6 +310,21 @@ impl EcmascriptChunkPlaceable for EcmascriptModulePartAsset {
     async fn get_exports(self: Vc<Self>) -> Result<Vc<EcmascriptExports>> {
         Ok(self.analyze().await?.exports)
     }
+
+    #[turbo_tasks::function]
+    async fn is_marked_as_side_effect_free(
+        self: Vc<Self>,
+        side_effect_free_packages: Vc<Glob>,
+    ) -> Result<Vc<bool>> {
+        let this = self.await?;
+
+        match *this.part.await? {
+            ModulePart::Exports | ModulePart::Export(..) => Ok(Vc::cell(true)),
+            _ => Ok(this
+                .full_module
+                .is_marked_as_side_effect_free(side_effect_free_packages)),
+        }
+    }
 }
 
 #[turbo_tasks::value_impl]

turbopack/crates/turbopack/src/lib.rs

@@ -303,7 +303,13 @@ async fn apply_reexport_tree_shaking(
             module: final_module,
             export_name: new_export,
             ..
-        } = &*follow_reexports(module, export.clone_value(), side_effect_free_packages).await?;
+        } = &*follow_reexports(
+            module,
+            export.clone_value(),
+            side_effect_free_packages,
+            Vc::cell(false),
+        )
+        .await?;
         let module = if let Some(new_export) = new_export {
             if *new_export == *export {
                 Vc::upcast(*final_module)