fixup

Author: mischnic

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

@@ -7,6 +7,7 @@ use std::{
 };
 
 use anyhow::{Result, bail};
+use auto_hash_map::AutoSet;
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde::{Deserialize, Serialize};
 use tracing::{Instrument, Level};
@@ -108,8 +109,22 @@ impl ModuleResolveResultItem {
 pub enum ImportUsage {
     #[default]
     Global,
-    Exports(Vec<RcStr>),
+    Exports(AutoSet<RcStr>),
 }
+impl ImportUsage {
+    pub fn add_export(&mut self, user: &RcStr) {
+        match self {
+            ImportUsage::Exports(set) => {
+                set.insert(user.clone());
+            }
+            ImportUsage::Global => {}
+        }
+    }
+    pub fn make_global(&mut self) {
+        *self = ImportUsage::Global;
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl ImportUsage {
     #[turbo_tasks::function]

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

@@ -31,7 +31,7 @@ use super::{
 use crate::{
     AnalyzeMode, SpecifiedModuleType,
     analyzer::{WellKnownObjectKind, is_unresolved},
-    references::constant_value::parse_single_expr_lit,
+    references::{constant_value::parse_single_expr_lit, for_each_ident_in_pat},
     utils::{AstPathRange, unparen},
 };
 
@@ -308,32 +308,26 @@ impl VarMeta {
 }
 
 #[derive(Clone, Debug)]
-pub enum ImportUsage {
+pub enum DeclUsage {
     Global,
-    OnlyExports(FxHashSet<Id>),
+    Bindings(FxHashSet<Id>),
 }
-impl ImportUsage {
-    fn add_export(&mut self, user: &Id) {
+impl Default for DeclUsage {
+    fn default() -> Self {
+        DeclUsage::Bindings(Default::default())
+    }
+}
+impl DeclUsage {
+    fn add_usage(&mut self, user: &Id) {
         match self {
-            ImportUsage::OnlyExports(set) => {
+            Self::Bindings(set) => {
                 set.insert(user.clone());
             }
-            ImportUsage::Global => {}
+            Self::Global => {}
         }
     }
     fn make_global(&mut self) {
-        *self = ImportUsage::Global;
-    }
-}
-
-impl From<ImportUsage> for turbopack_core::resolve::ImportUsage {
-    fn from(value: ImportUsage) -> Self {
-        match value {
-            ImportUsage::OnlyExports(exports) => {
-                Self::Exports(exports.into_iter().map(|id| RcStr::from(&*id.0)).collect())
-            }
-            ImportUsage::Global => Self::Global,
-        }
+        *self = Self::Global;
     }
 }
 
@@ -347,9 +341,11 @@ pub struct VarGraph {
     pub effects: Vec<Effect>,
 
     // ident -> immediate usage (top level decl)
-    pub top_level_mappings: FxHashMap<Id, FxHashSet<Id>>,
+    pub decl_usages: FxHashMap<Id, DeclUsage>,
     // import -> immediate usage (top level decl)
-    pub import_usages: FxHashMap<usize, ImportUsage>,
+    pub import_usages: FxHashMap<usize, DeclUsage>,
+    // export name -> top level decl
+    pub exports: FxHashMap<Atom, Id>,
 }
 
 impl VarGraph {
@@ -374,8 +370,9 @@ pub fn create_graph(
         values: Default::default(),
         free_var_ids: Default::default(),
         effects: Default::default(),
-        top_level_mappings: Default::default(),
+        decl_usages: Default::default(),
         import_usages: Default::default(),
+        exports: Default::default(),
     };
 
     m.visit_with_ast_path(
@@ -2263,9 +2260,9 @@ impl VisitAstPath for Analyzer<'_> {
                 .data
                 .import_usages
                 .entry(esm_reference_index)
-                .or_insert_with(|| ImportUsage::OnlyExports(Default::default()));
+                .or_default();
             if let Some(top_level) = self.state.cur_top_level_decl_name() {
-                usage.add_export(top_level);
+                usage.add_usage(top_level);
             } else {
                 usage.make_global();
             }
@@ -2317,15 +2314,22 @@ impl VisitAstPath for Analyzer<'_> {
             })
         }
 
-        if !is_unresolved(ident, self.eval_context.unresolved_mark)
-            && let Some(top_level) = self.state.cur_top_level_decl_name()
-            && !(ident.sym == top_level.0 && ident.ctxt == top_level.1)
-        {
-            self.data
-                .top_level_mappings
-                .entry(ident.to_id())
-                .or_default()
-                .insert(top_level.clone());
+        if !is_unresolved(ident, self.eval_context.unresolved_mark) {
+            if let Some(top_level) = self.state.cur_top_level_decl_name() {
+                if !(ident.sym == top_level.0 && ident.ctxt == top_level.1) {
+                    self.data
+                        .decl_usages
+                        .entry(ident.to_id())
+                        .or_default()
+                        .add_usage(top_level);
+                }
+            } else {
+                self.data
+                    .decl_usages
+                    .entry(ident.to_id())
+                    .or_default()
+                    .make_global();
+            }
         }
     }
 
@@ -2665,6 +2669,53 @@ impl VisitAstPath for Analyzer<'_> {
         self.effects = prev_effects;
         self.early_return_stack = prev_early_return_stack;
     }
+
+    fn visit_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDecl,
+        ast_path: &mut swc_core::ecma::visit::AstNodePath<'r>,
+    ) {
+        match &node.decl {
+            Decl::Class(node) => {
+                self.data
+                    .exports
+                    .insert(node.ident.sym.clone(), node.ident.to_id());
+            }
+            Decl::Fn(node) => {
+                self.data
+                    .exports
+                    .insert(node.ident.sym.clone(), node.ident.to_id());
+            }
+            Decl::Var(node) => {
+                for VarDeclarator { name, .. } in &node.decls {
+                    for_each_ident_in_pat(name, &mut |name, ctxt| {
+                        self.data.exports.insert(name.clone(), (name.clone(), ctxt));
+                    });
+                }
+            }
+            _ => {}
+        };
+        node.visit_children_with_ast_path(self, ast_path);
+    }
+
+    fn visit_export_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamedSpecifier,
+        ast_path: &mut swc_core::ecma::visit::AstNodePath<'r>,
+    ) {
+        let export_name = match &node.exported {
+            Some(ident) => ident.atom().clone(),
+            None => node.orig.atom().clone(),
+        };
+        self.data.exports.insert(
+            export_name,
+            match &node.orig {
+                ModuleExportName::Ident(ident) => ident.to_id(),
+                ModuleExportName::Str(_) => unreachable!("exporting a string should be impossible"),
+            },
+        );
+        node.visit_children_with_ast_path(self, ast_path);
+    }
 }
 
 fn is_lexically_block_scope(ast_path: &mut AstNodePath<AstParentNodeRef>) -> bool {

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

@@ -41,7 +41,7 @@ use serde::{Deserialize, Serialize};
 use swc_core::{
     atoms::{Atom, atom},
     common::{
-        GLOBALS, Globals, Span, Spanned,
+        GLOBALS, Globals, Span, Spanned, SyntaxContext,
         comments::{CommentKind, Comments},
         errors::{DiagnosticId, HANDLER, Handler},
         pass::AstNodePath,
@@ -77,7 +77,7 @@ use turbopack_core::{
     reference::{ModuleReference, ModuleReferences},
     reference_type::{CommonJsReferenceSubType, ReferenceType},
     resolve::{
-        FindContextFileResult, ModulePart, find_context_file,
+        FindContextFileResult, ImportUsage, ModulePart, find_context_file,
         origin::{PlainResolveOrigin, ResolveOrigin, ResolveOriginExt},
         parse::Request,
         pattern::Pattern,
@@ -132,7 +132,7 @@ use crate::{
     analyzer::{
         ConstantNumber, ConstantString, JsValueUrlKind, RequireContextValue,
         builtin::early_replace_builtin,
-        graph::{ConditionalKind, EffectArg, EvalContext, ImportUsage, VarGraph},
+        graph::{ConditionalKind, DeclUsage, EffectArg, EvalContext, VarGraph},
         imports::{ImportAnnotations, ImportAttributes, ImportedSymbol, Reexport},
         parse_require_context,
         top_level_await::has_top_level_await,
@@ -709,23 +709,44 @@ async fn analyze_ecmascript_module_internal(
         FxHashMap::with_capacity_and_hasher(var_graph.import_usages.len(), Default::default());
     for (reference, usage) in &var_graph.import_usages {
         // TODO make this more efficient, i.e. cache the result?
-        if let ImportUsage::OnlyExports(ids) = usage {
+        if let DeclUsage::Bindings(ids) = usage {
             // compute transitive closure of `ids` over `top_level_mappings`
             let mut visited = ids.clone();
             let mut stack = ids.iter().collect::<Vec<_>>();
-
+            let mut has_global_usage = false;
             while let Some(id) = stack.pop() {
-                if let Some(callers) = var_graph.top_level_mappings.get(id) {
-                    for caller in callers {
-                        if visited.insert(caller.clone()) {
-                            stack.push(caller);
+                match var_graph.decl_usages.get(id) {
+                    Some(DeclUsage::Global) => {
+                        has_global_usage = true;
+                        break;
+                    }
+                    Some(DeclUsage::Bindings(callers)) => {
+                        for caller in callers {
+                            if visited.insert(caller.clone()) {
+                                stack.push(caller);
+                            }
                         }
                     }
+                    _ => {}
                 }
             }
 
-            // TODO filter out the non-export declarations here
-            import_usage.insert(*reference, ImportUsage::OnlyExports(visited));
+            // Collect all `visited` declarations which are exported
+            import_usage.insert(
+                *reference,
+                if has_global_usage {
+                    ImportUsage::Global
+                } else {
+                    ImportUsage::Exports(
+                        var_graph
+                            .exports
+                            .iter()
+                            .filter(|(_, id)| visited.contains(*id))
+                            .map(|(exported, _)| exported.as_str().into())
+                            .collect(),
+                    )
+                },
+            );
         }
     }
 
@@ -769,11 +790,7 @@ async fn analyze_ecmascript_module_internal(
                     )
                     .then(ModulePart::exports),
                 },
-                import_usage
-                    .get(&i)
-                    .cloned()
-                    .map(Into::into)
-                    .unwrap_or_default(),
+                import_usage.get(&i).cloned().unwrap_or_default(),
                 import_externals,
             )
             .resolved_cell();
@@ -1413,8 +1430,8 @@ async fn analyze_ecmascript_module_internal(
                                                 original_reference.issue_source,
                                                 original_reference.annotations.clone(),
                                                 Some(ModulePart::export(export.clone())),
-                                                // TODO this rewriting is annoying
-                                                ImportUsage::Global.into(),
+                                                // TODO this reference rewriting is annoying
+                                                ImportUsage::Global,
                                                 original_reference.import_externals,
                                             )
                                             .resolved_cell()
@@ -2821,7 +2838,7 @@ async fn handle_free_var_reference(
                             ) => export.clone().map(ModulePart::export),
                             None => None,
                         },
-                        ImportUsage::Global.into(),
+                        ImportUsage::Global,
                         state.import_externals,
                     )
                     .resolved_cell())
@@ -3448,10 +3465,10 @@ fn as_parent_path(ast_path: &AstNodePath<AstParentNodeRef<'_>>) -> Vec<AstParent
     ast_path.iter().map(|n| n.kind()).collect()
 }
 
-fn for_each_ident_in_pat(pat: &Pat, f: &mut impl FnMut(RcStr)) {
+pub(crate) fn for_each_ident_in_pat(pat: &Pat, f: &mut impl FnMut(&Atom, SyntaxContext)) {
     match pat {
         Pat::Ident(BindingIdent { id, .. }) => {
-            f(id.sym.as_str().into());
+            f(&id.sym, id.ctxt);
         }
         Pat::Array(ArrayPat { elems, .. }) => elems.iter().for_each(|e| {
             if let Some(e) = e {
@@ -3467,7 +3484,7 @@ fn for_each_ident_in_pat(pat: &Pat, f: &mut impl FnMut(RcStr)) {
                     for_each_ident_in_pat(value, f);
                 }
                 ObjectPatProp::Assign(AssignPatProp { key, .. }) => {
-                    f(key.sym.as_str().into());
+                    f(&key.sym, key.ctxt);
                 }
                 ObjectPatProp::Rest(RestPat { arg, .. }) => {
                     for_each_ident_in_pat(arg, f);
@@ -3600,8 +3617,8 @@ impl VisitAstPath for ModuleReferencesVisitor<'_> {
                     };
                     let decls = &*var_decl.decls;
                     decls.iter().for_each(|VarDeclarator { name, .. }| {
-                        for_each_ident_in_pat(name, &mut |name| {
-                            insert_export_binding(name, liveness)
+                        for_each_ident_in_pat(name, &mut |name, _| {
+                            insert_export_binding(name.as_str().into(), liveness)
                         })
                     });
                 }