fix: hash not stable (&revert import * as optimize)

.github/workflows/ci.yml

@@ -115,6 +115,8 @@ jobs:
       - name: LS
         run: ls -l ./packages/mako
       - name: Test E2E
+        env:
+          RUST_BACKTRACE: full
         run: pnpm ${{ matrix.script }}
 
   lint:

crates/mako/src/module_graph.rs

@@ -9,7 +9,7 @@
 use petgraph::Direction;
 use tracing::{debug, warn};
 
-use crate::module::{Dependencies, Dependency, Module, ModuleId, ResolveType};
+use crate::module::{Dependencies, Dependency, Module, ModuleId};
 
 #[derive(Debug)]
 pub struct ModuleGraph {
@@ -304,29 +304,14 @@
         targets
     }
 
-    pub fn remove_dependency_module_by_source_and_resolve_type(
-        &mut self,
-        module_id: &ModuleId,
-        source: &String,
-        resolve_type: ResolveType,
-    ) {
+    pub fn rewrite_dependency(&mut self, module_id: &ModuleId, deps: Vec<(ModuleId, Dependency)>) {
         let mut edges = self.get_edges(module_id, Direction::Outgoing);
-
         while let Some((edge_index, _node_index)) = edges.next(&self.graph) {
-            let dependencies = self.graph.edge_weight_mut(edge_index).unwrap();
-
-            if let Some(to_del_dep) = dependencies
-                .iter()
-                .position(|dep| *source == dep.source && dep.resolve_type.same_enum(&resolve_type))
-            {
-                dependencies.take(&dependencies.iter().nth(to_del_dep).unwrap().clone());
-
-                if dependencies.is_empty() {
-                    self.graph.remove_edge(edge_index);
-                }
-                return;
-            }
+            self.graph.remove_edge(edge_index);
         }
+        deps.into_iter().for_each(|(m, d)| {
+            self.add_dependency(module_id, &m, d);
+        });
     }
 
     pub fn get_dependency_module_by_source(

crates/mako/src/plugins/tree_shaking.rs

@@ -9,6 +9,7 @@ use crate::compiler::Context;
 use crate::module_graph::ModuleGraph;
 use crate::plugin::{Plugin, PluginTransformJsParam};
 
+mod collect_explicit_prop;
 mod module;
 mod module_side_effects_flag;
 mod remove_useless_stmts;

crates/mako/src/plugins/tree_shaking/collect_explicit_prop.rs

@@ -0,0 +1,222 @@
+use std::collections::{HashMap, HashSet};
+
+use swc_core::ecma::ast::{ComputedPropName, Id, Ident, Lit, MemberExpr, MemberProp};
+use swc_core::ecma::visit::{Visit, VisitWith};
+
+#[derive(Debug)]
+pub struct IdExplicitPropAccessCollector {
+    to_detected: HashSet<Id>,
+    accessed_by_explicit_prop_count: HashMap<Id, usize>,
+    ident_accessed_count: HashMap<Id, usize>,
+    accessed_by: HashMap<Id, HashSet<String>>,
+}
+
+impl IdExplicitPropAccessCollector {
+    pub(crate) fn new(ids: HashSet<Id>) -> Self {
+        Self {
+            to_detected: ids,
+            accessed_by_explicit_prop_count: Default::default(),
+            ident_accessed_count: Default::default(),
+            accessed_by: Default::default(),
+        }
+    }
+    pub(crate) fn explicit_accessed_props(mut self) -> HashMap<String, Vec<String>> {
+        self.to_detected
+            .iter()
+            .filter_map(|id| {
+                let member_prop_accessed = self.accessed_by_explicit_prop_count.get(id);
+                let ident_accessed = self.ident_accessed_count.get(id);
+
+                match (member_prop_accessed, ident_accessed) {
+                    // all ident are accessed explicitly, so there is member expr there is a name
+                    // ident, and at last plus the extra ident in import decl, that's 1 comes from.
+                    (Some(m), Some(i)) if (i - m) == 1 => {
+                        let mut accessed_by = Vec::from_iter(self.accessed_by.remove(id).unwrap());
+                        accessed_by.sort();
+
+                        let str_key = format!("{}#{}", id.0, id.1.as_u32());
+
+                        Some((str_key, accessed_by))
+                    }
+                    // Some un-explicitly access e.g: obj[foo]
+                    _ => None,
+                }
+            })
+            .collect()
+    }
+
+    fn increase_explicit_prop_accessed_count(&mut self, id: Id) {
+        self.accessed_by_explicit_prop_count
+            .entry(id.clone())
+            .and_modify(|c| {
+                *c += 1;
+            })
+            .or_insert(1);
+    }
+
+    fn insert_member_accessed_by(&mut self, id: Id, prop: &str) {
+        self.increase_explicit_prop_accessed_count(id.clone());
+        self.accessed_by
+            .entry(id)
+            .and_modify(|accessed| {
+                accessed.insert(prop.to_string());
+            })
+            .or_insert(HashSet::from([prop.to_string()]));
+    }
+}
+
+impl Visit for IdExplicitPropAccessCollector {
+    fn visit_ident(&mut self, n: &Ident) {
+        let id = n.to_id();
+
+        if self.to_detected.contains(&id) {
+            self.ident_accessed_count
+                .entry(id)
+                .and_modify(|c| {
+                    *c += 1;
+                })
+                .or_insert(1);
+        }
+    }
+
+    fn visit_member_expr(&mut self, n: &MemberExpr) {
+        if let Some(obj_ident) = n.obj.as_ident() {
+            let id = obj_ident.to_id();
+
+            if self.to_detected.contains(&id) {
+                match &n.prop {
+                    MemberProp::Ident(prop_ident) => {
+                        self.insert_member_accessed_by(id, prop_ident.sym.as_ref());
+                    }
+                    MemberProp::PrivateName(_) => {}
+                    MemberProp::Computed(ComputedPropName { expr, .. }) => {
+                        if let Some(lit) = expr.as_lit()
+                            && let Lit::Str(str) = lit
+                        {
+                            let visited_by = str.value.to_string();
+                            self.insert_member_accessed_by(id, &visited_by)
+                        }
+                    }
+                }
+            }
+        }
+
+        n.visit_children_with(self);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use maplit::hashset;
+
+    use super::*;
+    use crate::ast::tests::TestUtils;
+
+    #[test]
+    fn test_no_prop() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        console.log(foo)
+        "#,
+        );
+
+        assert_eq!(fields, None);
+    }
+    #[test]
+    fn test_no_access() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        "#,
+        );
+
+        assert_eq!(fields, None);
+    }
+
+    #[test]
+    fn test_computed_prop() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        foo['f' + 'o' + 'o']
+        "#,
+        );
+
+        assert_eq!(fields, None);
+    }
+
+    #[test]
+    fn test_simple_explicit_prop() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        foo.x;
+        foo.y;
+        "#,
+        );
+
+        assert_eq!(fields.unwrap(), vec!["x".to_string(), "y".to_string()]);
+    }
+
+    #[test]
+    fn test_nest_prop_explicit_prop() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        foo.x.z[foo.y]
+        "#,
+        );
+
+        assert_eq!(fields.unwrap(), vec!["x".to_string(), "y".to_string()]);
+    }
+
+    #[test]
+    fn test_string_literal_prop_explicit() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        foo['x']
+        "#,
+        );
+
+        assert_eq!(fields.unwrap(), vec!["x".to_string()]);
+    }
+
+    #[test]
+    fn test_num_literal_prop_not_explicit() {
+        let fields = extract_explicit_fields(
+            r#"
+        import * as foo from "./foo.js";
+        foo[1]
+        "#,
+        );
+
+        assert_eq!(fields, None);
+    }
+
+    fn extract_explicit_fields(code: &str) -> Option<Vec<String>> {
+        let tu = TestUtils::gen_js_ast(code);
+
+        let id = namespace_id(&tu);
+        let str = format!("{}#{}", id.0, id.1.as_u32());
+
+        let mut v = IdExplicitPropAccessCollector::new(hashset! { id });
+        tu.ast.js().ast.visit_with(&mut v);
+
+        v.explicit_accessed_props().remove(&str)
+    }
+
+    fn namespace_id(tu: &TestUtils) -> Id {
+        tu.ast.js().ast.body[0]
+            .as_module_decl()
+            .unwrap()
+            .as_import()
+            .unwrap()
+            .specifiers[0]
+            .as_namespace()
+            .unwrap()
+            .local
+            .to_id()
+    }
+}

crates/mako/src/plugins/tree_shaking/remove_useless_stmts.rs

@@ -1,9 +1,16 @@
+use std::collections::HashSet;
+
+use swc_core::common::util::take::Take;
+use swc_core::common::SyntaxContext;
 use swc_core::ecma::ast::{
-    Decl, ExportDecl, ExportSpecifier, ImportDecl, ImportSpecifier, Module as SwcModule,
-    ModuleExportName,
+    Decl, ExportDecl, ExportSpecifier, Id, ImportDecl, ImportSpecifier, Module as SwcModule,
+    Module, ModuleExportName,
 };
+use swc_core::ecma::transforms::compat::es2015::destructuring;
+use swc_core::ecma::transforms::compat::es2018::object_rest_spread;
 use swc_core::ecma::visit::{VisitMut, VisitMutWith, VisitWith};
 
+use super::collect_explicit_prop::IdExplicitPropAccessCollector;
 use crate::plugins::tree_shaking::module::TreeShakeModule;
 use crate::plugins::tree_shaking::statement_graph::analyze_imports_and_exports::{
     analyze_imports_and_exports, StatementInfo,
@@ -105,10 +112,10 @@
 
     // remove from the end to the start
     stmts_to_remove.reverse();
-
     for stmt in stmts_to_remove {
         swc_module.body.remove(stmt);
     }
+    optimize_import_namespace(&mut used_import_infos, swc_module);
 
     (used_import_infos, used_export_from_infos)
 }
@@ -231,6 +238,72 @@
     }
 }
 
+fn optimize_import_namespace(import_infos: &mut [ImportInfo], module: &mut Module) {
+    let namespaces = import_infos
+        .iter()
+        .filter_map(|import_info| {
+            let ns = import_info
+                .specifiers
+                .iter()
+                .filter_map(|sp| match sp {
+                    ImportSpecifierInfo::Namespace(ns) => Some(ns.clone()),
+                    _ => None,
+                })
+                .collect::<Vec<String>>();
+            if ns.is_empty() {
+                None
+            } else {
+                Some(ns)
+            }
+        })
+        .flatten()
+        .collect::<Vec<String>>();
+
+    let ids = namespaces
+        .iter()
+        .map(|ns| {
+            let (sym, ctxt) = ns.rsplit_once('#').unwrap();
+            (sym.into(), SyntaxContext::from_u32(ctxt.parse().unwrap()))
+        })
+        .collect::<HashSet<Id>>();
+
+    if !ids.is_empty() {
+        let mut v = IdExplicitPropAccessCollector::new(ids);
+        let mut shadow = module.clone();
+
+        shadow.visit_mut_with(&mut object_rest_spread(Default::default()));
+        shadow.visit_mut_with(&mut destructuring(Default::default()));
+        shadow.visit_with(&mut v);
+
+        let explicit_prop_accessed_ids = v.explicit_accessed_props();
+
+        import_infos.iter_mut().for_each(|ii| {
+            ii.specifiers = ii
+                .specifiers
+                .take()
+                .into_iter()
+                .flat_map(|specifier_info| {
+                    if let ImportSpecifierInfo::Namespace(ref ns) = specifier_info {
+                        if let Some(visited_fields) = explicit_prop_accessed_ids.get(ns) {
+                            return visited_fields
+                                .iter()
+                                .map(|v| {
+                                    let imported_name = format!("{v}#0");
+                                    ImportSpecifierInfo::Named {
+                                        imported: Some(imported_name.clone()),
+                                        local: imported_name,
+                                    }
+                                })
+                                .collect::<Vec<_>>();
+                        }
+                    }
+                    vec![specifier_info]
+                })
+                .collect::<Vec<_>>();
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;