Merge branch 'main' into feat-pluginutils-create_filter

.changeset/neat-windows-nail.md

@@ -0,0 +1,5 @@
+---
+'@farmfe/js-plugin-visualizer': major
+---
+
+rename as js-plugin-visualizer

crates/compiler/tests/fixtures/tree_shake/self-executed/class/static/foo.ts

@@ -0,0 +1,5 @@
+export class Foo {
+  static bar() {}
+}
+
+Foo.bar();

crates/compiler/tests/fixtures/tree_shake/self-executed/class/static/index.ts

@@ -0,0 +1,3 @@
+import { Foo } from './foo';
+
+console.log(Foo);

crates/compiler/tests/fixtures/tree_shake/self-executed/class/static/output.js

@@ -0,0 +1,30 @@
+//index.js:
+ (globalThis || window || global)['__farm_default_namespace__'] = {__FARM_TARGET_ENV__: 'browser'};(function(r,e){var t={};function n(r){return Promise.resolve(o(r))}function o(e){if(t[e])return t[e].exports;var i={id:e,exports:{}};r[e](i,i.exports,o,n);t[e]=i;return i.exports}o(e)})({"0b3bded0":function  (module, exports, farmRequire, farmDynamicRequire) {
+    console.log("runtime/index.js")(globalThis || window || global)["__farm_default_namespace__"].__farm_module_system__.setPlugins([]);
+}
+,},"0b3bded0");(function(_){for(var r in _){_[r].__farm_resource_pot__='index_e094.js';(globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__.register(r,_[r])}})({"6d686e48":function  (module, exports, farmRequire, farmDynamicRequire) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    Object.defineProperty(exports, "Foo", {
+        enumerable: true,
+        get: function() {
+            return Foo;
+        }
+    });
+    class Foo {
+        static bar() {}
+    }
+    Foo.bar();
+}
+,
+"b5d64806":function  (module, exports, farmRequire, farmDynamicRequire) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    var _foo = farmRequire("6d686e48");
+    console.log(_foo.Foo);
+}
+,});(globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__.setInitialLoadedResources([]);(globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__.setDynamicModuleResourcesMap({  });var farmModuleSystem = (globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__;farmModuleSystem.bootstrap();var entry = farmModuleSystem.require("b5d64806");

crates/compiler/tests/fixtures/tree_shake/self-executed/decl/vars_reverse_read/dep.ts

@@ -0,0 +1,34 @@
+const a1 = {};
+
+const b1 = { a1 };
+
+const c1 = { b1 };
+
+const d1 = { c1 };
+
+const e1 = { d1 };
+
+export { a1 };
+
+const a2 = {};
+const b2 = { a2 };
+
+b2.a2.aaa = 2;
+
+export { a2 };
+
+const a3 = {};
+
+const b3 = { a3 };
+
+console.log(b3);
+
+const c3 = { b3 };
+
+console.log(c3);
+
+const d3 = { c3 };
+
+const e3 = { d3 };
+
+export { a3 };

crates/compiler/tests/fixtures/tree_shake/self-executed/decl/vars_reverse_read/index.ts

@@ -0,0 +1,3 @@
+import { a1, a2, a3 } from './dep';
+
+console.log(a1, a2, a3);

crates/compiler/tests/fixtures/tree_shake/self-executed/decl/vars_reverse_read/output.js

@@ -0,0 +1,52 @@
+//index.js:
+ (globalThis || window || global)['__farm_default_namespace__'] = {__FARM_TARGET_ENV__: 'browser'};(function(r,e){var t={};function n(r){return Promise.resolve(o(r))}function o(e){if(t[e])return t[e].exports;var i={id:e,exports:{}};r[e](i,i.exports,o,n);t[e]=i;return i.exports}o(e)})({"0b3bded0":function  (module, exports, farmRequire, farmDynamicRequire) {
+    console.log("runtime/index.js")(globalThis || window || global)["__farm_default_namespace__"].__farm_module_system__.setPlugins([]);
+}
+,},"0b3bded0");(function(_){for(var r in _){_[r].__farm_resource_pot__='index_ddf1.js';(globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__.register(r,_[r])}})({"05ee5ec7":function  (module, exports, farmRequire, farmDynamicRequire) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    function _export(target, all) {
+        for(var name in all)Object.defineProperty(target, name, {
+            enumerable: true,
+            get: all[name]
+        });
+    }
+    _export(exports, {
+        a1: function() {
+            return a1;
+        },
+        a2: function() {
+            return a2;
+        },
+        a3: function() {
+            return a3;
+        }
+    });
+    const a1 = {};
+    const a2 = {};
+    const b2 = {
+        a2
+    };
+    b2.a2.aaa = 2;
+    const a3 = {};
+    const b3 = {
+        a3
+    };
+    console.log(b3);
+    const c3 = {
+        b3
+    };
+    console.log(c3);
+}
+,
+"b5d64806":function  (module, exports, farmRequire, farmDynamicRequire) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    var _dep = farmRequire("05ee5ec7");
+    console.log(_dep.a1, _dep.a2, _dep.a3);
+}
+,});(globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__.setInitialLoadedResources([]);(globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__.setDynamicModuleResourcesMap({  });var farmModuleSystem = (globalThis || window || global)['__farm_default_namespace__'].__farm_module_system__;farmModuleSystem.bootstrap();var entry = farmModuleSystem.require("b5d64806");

crates/plugin_tree_shake/src/module.rs

@@ -1,4 +1,5 @@
 use std::{
+  borrow::Cow,
   collections::{HashMap, HashSet},
   mem,
 };
@@ -44,6 +45,18 @@ pub enum UsedExports {
   Partial(HashMap<ModuleId, Vec<String>>),
 }
 
+#[derive(Debug)]
+enum VisitedMode {
+  Normal,
+  Enforce,
+}
+
+impl VisitedMode {
+  fn removable(&self) -> bool {
+    !matches!(self, VisitedMode::Enforce)
+  }
+}
+
 impl UsedExports {
   pub fn add_used_export(&mut self, module_id: &ModuleId, used_export: &dyn ToString) {
     match self {
@@ -302,39 +315,93 @@ impl TreeShakeModule {
         entry: &'a ItemId,
         stack: &mut Vec<&'a ItemId>,
         result: &mut HashSet<ItemId>,
-        visited: &mut HashSet<&'a ItemId>,
+        visited: &mut HashMap<&'a ItemId, VisitedMode>,
         module_define_graph: &'a ModuleAnalyze,
         stmt_graph: &StatementGraph,
-      ) {
-        stack.push(entry);
-
-        let edges = module_define_graph.reference_edges(entry);
+        reverse_terser_chain: &mut Vec<Mode>,
+      ) -> bool {
+        let collection_result = |visited: &mut HashMap<&'a ItemId, VisitedMode>,
+                                 reverse_terser_chain: &mut Vec<Mode>,
+                                 result: &mut HashSet<ItemId>,
+                                 stack: &mut Vec<&'a ItemId>| {
+          if !reverse_terser_chain.is_empty() {
+            if reverse_terser_chain
+              .iter()
+              .any(|mode| matches!(mode, Mode::Write))
+            {
+              let collections = stack.iter().map(|item| (*item).clone()).collect::<Vec<_>>();
+
+              for item in collections {
+                visited
+                  .get_mut(&item)
+                  .map(|item| *item = VisitedMode::Enforce);
+                result.insert(item);
+              }
+              true
+            } else {
+              false
+            }
+          } else {
+            result.extend(stack.iter().map(|item| (*item).clone()).collect::<Vec<_>>());
+            true
+          }
+        };
 
-        let collection_result = |result: &mut HashSet<ItemId>, stack: &mut Vec<&'a ItemId>| {
-          result.extend(stack.iter().map(|item| (*item).clone()).collect::<Vec<_>>());
-          stack.clear();
+        let break_tenser = |stack: &mut Vec<&'a ItemId>| {
+          stack.pop();
         };
 
-        if visited.contains(entry) || !module_define_graph.has_node(entry) {
-          collection_result(result, stack);
-          return;
+        if visited.contains_key(entry) {
+          return collection_result(visited, reverse_terser_chain, result, stack);
+        }
+
+        stack.push(entry);
+
+        if !module_define_graph.has_node(entry) {
+          let is_collected = collection_result(visited, reverse_terser_chain, result, stack);
+          break_tenser(stack);
+          return is_collected;
         }
 
-        if edges.is_empty() {
-          collection_result(result, stack);
+        let edges = module_define_graph.reference_edges(entry);
+
+        if edges.is_empty() || edges.iter().all(|(source, target, _)| source == target) {
+          let is_collected = collection_result(visited, reverse_terser_chain, result, stack);
+          break_tenser(stack);
+          is_collected
         } else {
-          visited.insert(entry);
+          visited.insert(entry, VisitedMode::Normal);
+          let mut is_contain_reverse_edge = false;
+          let mut is_collected = false;
+          let push_reverse_terser_chain =
+            |reverse_terser_chain: &mut Vec<Mode>, mode: Mode, create| {
+              if !reverse_terser_chain.is_empty() || create {
+                reverse_terser_chain.push(mode);
+              }
+            };
+
+          let pop_reverse_terser_chain = |reverse_terser_chain: &mut Vec<Mode>| {
+            reverse_terser_chain.pop();
+          };
+
           for (source, target, edge) in edges {
+            if source == target {
+              continue;
+            }
+
             match (edge.mode, edge.nested) {
               (Mode::Read, _) => {
-                dfs(
+                push_reverse_terser_chain(reverse_terser_chain, Mode::Read, false);
+                is_collected = dfs(
                   target,
                   stack,
                   result,
                   visited,
                   module_define_graph,
                   stmt_graph,
-                );
+                  reverse_terser_chain,
+                ) || is_collected;
+                pop_reverse_terser_chain(reverse_terser_chain);
 
                 // ignore nested
                 // cache -> readCache { cache }
@@ -367,48 +434,72 @@ impl TreeShakeModule {
                     }
                   )
                 {
-                  dfs(
+                  is_contain_reverse_edge = true;
+                  push_reverse_terser_chain(reverse_terser_chain, Mode::Read, true);
+                  is_collected = dfs(
                     source,
                     stack,
                     result,
                     visited,
                     module_define_graph,
                     stmt_graph,
-                  );
+                    reverse_terser_chain,
+                  ) || is_collected;
+                  pop_reverse_terser_chain(reverse_terser_chain);
                 }
               }
 
               (Mode::Write, false) => {
-                dfs(
+                push_reverse_terser_chain(reverse_terser_chain, Mode::Write, false);
+                is_collected = dfs(
                   source,
                   stack,
                   result,
                   visited,
                   module_define_graph,
                   stmt_graph,
-                );
+                  reverse_terser_chain,
+                ) || is_collected;
+                pop_reverse_terser_chain(reverse_terser_chain);
               }
 
               (Mode::Write, true) => {
-                dfs(
+                push_reverse_terser_chain(reverse_terser_chain, Mode::Write, false);
+                is_collected = dfs(
                   target,
                   stack,
                   result,
                   visited,
                   module_define_graph,
                   stmt_graph,
-                );
+                  reverse_terser_chain,
+                ) || is_collected;
+                pop_reverse_terser_chain(reverse_terser_chain);
               }
             }
           }
-        }
 
-        stack.pop();
+          if is_contain_reverse_edge && !is_collected {
+            if let Some(mode) = visited.get(entry) {
+              if mode.removable() {
+                visited.remove(entry);
+              }
+            }
+          }
+
+          break_tenser(stack);
+
+          is_collected
+        }
       }
 
-      let mut visited = HashSet::new();
+      let mut visited = HashMap::new();
       let mut reference_chain = HashSet::new();
 
+      let mut entries = entries.into_iter().collect::<Vec<_>>();
+
+      entries.sort_by(|a, b| a.index().cmp(&b.index()));
+
       for stmt in &entries {
         dfs(
           stmt,
@@ -417,6 +508,7 @@ impl TreeShakeModule {
           &mut visited,
           &module_analyze,
           &self.stmt_graph,
+          &mut vec![],
         );
       }
 

crates/plugin_tree_shake/src/statement_graph/module_analyze.rs

@@ -347,10 +347,14 @@ impl ModuleAnalyze {
         }
 
         _ => {
-          let used_ids = collect_usage_ignore_nested(stmt, None);
+          let used_ids = collect_all_usage(stmt, None);
+
           let data = ItemData {
             read_vars: used_ids.vars.read,
             write_vars: used_ids.vars.write,
+            nested_read_vars: used_ids.vars.nested_read,
+            nested_write_vars: used_ids.vars.nested_write,
+            side_effect_call: used_ids.call_reads,
             ..Default::default()
           };
 

cspell.json

@@ -157,6 +157,7 @@
     "shulandmimi",
     "concurrentify",
     "pageerror",
+    "rsdoctor",
     "deepmerge",
     "Mergeable",
     "globset"