fix(turbopack): Fix tree shaking with import * as R

turbopack/crates/turbopack-ecmascript/src/analyzer/graph.rs

@@ -329,6 +329,14 @@ impl EvalContext {
         }
     }
 
+    fn eval_member_prop(&self, prop: &MemberProp) -> Option<JsValue> {
+        match prop {
+            MemberProp::Ident(ident) => Some(ident.sym.clone().into()),
+            MemberProp::Computed(ComputedPropName { expr, .. }) => Some(self.eval(expr)),
+            MemberProp::PrivateName(_) => None,
+        }
+    }
+
     fn eval_tpl(&self, e: &Tpl, raw: bool) -> JsValue {
         debug_assert!(e.quasis.len() == e.exprs.len() + 1);
 
@@ -724,6 +732,17 @@ enum EarlyReturn {
     },
 }
 
+pub fn as_parent_path_skip(
+    ast_path: &AstNodePath<AstParentNodeRef<'_>>,
+    skip: usize,
+) -> Vec<AstParentKind> {
+    ast_path
+        .iter()
+        .take(ast_path.len() - skip)
+        .map(|n| n.kind())
+        .collect()
+}
+
 struct Analyzer<'a> {
     data: &'a mut VarGraph,
 
@@ -1804,6 +1823,48 @@ impl VisitAstPath for Analyzer<'_> {
         if let Some((esm_reference_index, export)) =
             self.eval_context.imports.get_binding(&ident.to_id())
         {
+            if export.is_none()
+                && !self
+                    .eval_context
+                    .imports
+                    .should_import_all(esm_reference_index)
+            {
+                // export.is_none() checks for a namespace import.
+
+                // Note: This is optimization that can be applied if we don't need to
+                // import all bindings
+                if let Some(AstParentNodeRef::MemberExpr(member, MemberExprField::Obj)) =
+                    ast_path.get(ast_path.len() - 2)
+                {
+                    // Skip if it's on the LHS of assignment
+                    let is_lhs = matches!(
+                        ast_path.get(ast_path.len() - 3),
+                        Some(AstParentNodeRef::SimpleAssignTarget(
+                            _,
+                            SimpleAssignTargetField::Member
+                        ))
+                    );
+
+                    //
+                    if !is_lhs {
+                        if let Some(prop) = self.eval_context.eval_member_prop(&member.prop) {
+                            if let Some(prop_str) = prop.as_str() {
+                                // a namespace member access like
+                                // `import * as ns from "..."; ns.exportName`
+                                self.add_effect(Effect::ImportedBinding {
+                                    esm_reference_index,
+                                    export: Some(prop_str.into()),
+                                    ast_path: as_parent_path_skip(ast_path, 1),
+                                    span: member.span(),
+                                    in_try: is_in_try(ast_path),
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+
             self.add_effect(Effect::ImportedBinding {
                 esm_reference_index,
                 export,

turbopack/crates/turbopack-ecmascript/src/analyzer/imports.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use once_cell::sync::Lazy;
+use rustc_hash::FxHashSet;
 use swc_core::{
     common::{comments::Comments, source_map::SmallPos, BytePos, Span, Spanned},
     ecma::{
@@ -176,6 +177,10 @@ pub(crate) struct ImportMap {
     ///
     /// [magic]: https://webpack.js.org/api/module-methods/#magic-comments
     attributes: HashMap<BytePos, ImportAttributes>,
+
+    /// The module specifiers of star imports that are accessed dynamically and should be imported
+    /// as a whole.
+    full_star_imports: FxHashSet<JsWord>,
 }
 
 /// Represents a collection of [webpack-style "magic comments"][magic] that override import
@@ -305,14 +310,107 @@ impl ImportMap {
     ) -> Self {
         let mut data = ImportMap::default();
 
-        m.visit_with(&mut Analyzer {
+        // We have to analyze imports first to determine if a star import is dynamic.
+        // We can't do this in the visitor because import may (and likely) comes before usages, and
+        // a method invoked after visitor will not work because we need to preserve the import
+        // order.
+
+        if let Program::Module(m) = m {
+            let mut candidates = FxIndexMap::default();
+
+            // Imports are hoisted to the top of the module.
+            // So we have to collect all imports first.
+            m.body.iter().for_each(|stmt| {
+                if let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = stmt {
+                    for s in &import.specifiers {
+                        if let ImportSpecifier::Namespace(s) = s {
+                            candidates.insert(s.local.to_id(), import.src.value.clone());
+                        }
+                    }
+                }
+            });
+
+            let mut analyzer = StarImportAnalyzer {
+                candidates,
+                full_star_imports: &mut data.full_star_imports,
+            };
+            m.visit_with(&mut analyzer);
+        }
+
+        let mut analyzer = Analyzer {
             data: &mut data,
             source,
             comments,
-        });
+        };
+        m.visit_with(&mut analyzer);
 
         data
     }
+
+    pub(crate) fn should_import_all(&self, esm_reference_index: usize) -> bool {
+        let r = &self.references[esm_reference_index];
+
+        self.full_star_imports.contains(&r.module_path)
+    }
+}
+
+struct StarImportAnalyzer<'a> {
+    /// The local identifiers of the star imports
+    candidates: FxIndexMap<Id, JsWord>,
+    full_star_imports: &'a mut FxHashSet<JsWord>,
+}
+
+impl Visit for StarImportAnalyzer<'_> {
+    fn visit_expr(&mut self, node: &Expr) {
+        if let Expr::Ident(i) = node {
+            if let Some(module_path) = self.candidates.get(&i.to_id()) {
+                self.full_star_imports.insert(module_path.clone());
+                return;
+            }
+        }
+
+        node.visit_children_with(self);
+    }
+
+    fn visit_import_decl(&mut self, _: &ImportDecl) {}
+
+    fn visit_member_expr(&mut self, node: &MemberExpr) {
+        match &node.prop {
+            MemberProp::Ident(..) | MemberProp::PrivateName(..) => {
+                if node.obj.is_ident() {
+                    return;
+                }
+                // We can skip `visit_expr(obj)` because it's not a dynamic access
+                node.obj.visit_children_with(self);
+            }
+            MemberProp::Computed(..) => {
+                node.obj.visit_with(self);
+                node.prop.visit_with(self);
+            }
+        }
+    }
+
+    fn visit_pat(&mut self, pat: &Pat) {
+        if let Pat::Ident(i) = pat {
+            if let Some(module_path) = self.candidates.get(&i.to_id()) {
+                self.full_star_imports.insert(module_path.clone());
+                return;
+            }
+        }
+
+        pat.visit_children_with(self);
+    }
+
+    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
+        if let SimpleAssignTarget::Ident(i) = node {
+            if let Some(module_path) = self.candidates.get(&i.to_id()) {
+                self.full_star_imports.insert(module_path.clone());
+                return;
+            }
+        }
+
+        node.visit_children_with(self);
+    }
 }
 
 struct Analyzer<'a> {

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

@@ -1207,6 +1207,28 @@ pub(crate) async fn analyse_ecmascript_module_internal(
                                 .await?,
                         )
                     } else {
+                        let r = match options.tree_shaking_mode {
+                            Some(TreeShakingMode::ReexportsOnly) => {
+                                let r_ref = r.await?;
+                                if r_ref.export_name.is_none() && export.is_some() {
+                                    let export = export.clone().unwrap();
+                                    EsmAssetReference::new(
+                                        *r_ref.origin,
+                                        *r_ref.request,
+                                        *r_ref.issue_source,
+                                        Value::new(r_ref.annotations.clone()),
+                                        Some(ModulePart::export(export)),
+                                        r_ref.import_externals,
+                                    )
+                                    .to_resolved()
+                                    .await?
+                                } else {
+                                    r
+                                }
+                            }
+                            _ => r,
+                        };
+
                         analysis.add_local_reference(r);
                         analysis.add_import_reference(r);
                         analysis.add_binding(EsmBinding::new(

turbopack/crates/turbopack-tests/tests/execution/turbopack/side-effects-optimization/import-star/input/index.js

@@ -0,0 +1,15 @@
+import * as R from 'ramda';
+
+console.log((0, R.pipe)('a', 'b', 'c'));
+console.log(R.pipe('a', 'b', 'c'));
+
+
+it('should import only pipe.js', () => {
+  const modules = Object.keys(__turbopack_modules__);
+  expect(modules).toContainEqual(
+    expect.stringMatching(/input\/node_modules\/ramda\/pipe/)
+  );
+  expect(modules).not.toContainEqual(
+    expect.stringMatching(/input\/node_modules\/ramda\/index/)
+  );
+})

turbopack/crates/turbopack-tests/tests/execution/turbopack/side-effects-optimization/import-star/options.json

@@ -0,0 +1,3 @@
+{
+  "treeShakingMode": "reexports-only"
+}