feat: shake unused args in recursed functions

Author: kermanx

crates/jsshaker/src/dep/atom.rs

@@ -18,6 +18,12 @@ impl Debug for DepAtom {
   }
 }
 
+impl DepAtom {
+  pub fn placeholder() -> Self {
+    AstKind2::ENVIRONMENT.into()
+  }
+}
+
 impl<'a> CustomDepTrait<'a> for DepAtom {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     analyzer.include_atom(*self);

crates/jsshaker/src/value/function/cache.rs

@@ -115,7 +115,7 @@ pub struct FnCacheTrackDeps<'a> {
 }
 
 impl<'a> FnCacheTrackDeps<'a> {
-  pub fn wrap(
+  pub fn wrap<const UNKNOWN: bool>(
     analyzer: &Analyzer<'a>,
     call_id: DepAtom,
     this: &mut Entity<'a>,
@@ -129,18 +129,52 @@ impl<'a> FnCacheTrackDeps<'a> {
     for arg in args.elements {
       let arg_dep = EntityTrackerDep::default();
       arg_deps.push(arg_dep);
-      new_args.push(factory.computed(*arg, arg_dep));
+      new_args.push(if UNKNOWN {
+        factory.computed_unknown((*arg, arg_dep))
+      } else {
+        factory.computed(*arg, arg_dep)
+      });
     }
     args.elements = new_args.into_bump_slice();
     let rest_dep = if let Some(rest) = &mut args.rest {
       let rest_dep = EntityTrackerDep::default();
-      *rest = factory.computed(*rest, rest_dep);
+      *rest = if UNKNOWN {
+        factory.computed_unknown((*rest, rest_dep))
+      } else {
+        factory.computed(*rest, rest_dep)
+      };
+      Some(rest_dep)
+    } else if UNKNOWN {
+      let rest_dep = EntityTrackerDep::default();
+      args.rest = Some(factory.computed_unknown(rest_dep));
       Some(rest_dep)
     } else {
       None
     };
     Self { call_id, this: this_dep, args: arg_deps.into_bump_slice(), rest: rest_dep }
   }
+
+  pub fn assoc(
+    self,
+    analyzer: &mut Analyzer<'a>,
+    call_dep: Dep<'a>,
+    this: Entity<'a>,
+    args: &ArgumentsValue<'a>,
+  ) {
+    analyzer.add_assoc_dep(self.call_id, call_dep);
+    analyzer.add_assoc_entity_dep(self.this, this);
+    for (dep, arg) in self.args.iter().zip(args.elements.iter()) {
+      analyzer.add_assoc_entity_dep(*dep, *arg);
+    }
+    if let Some(dep) = self.rest {
+      if let Some(rest) = args.rest {
+        analyzer.add_assoc_entity_dep(dep, rest);
+      }
+      for arg in args.elements.iter().skip(self.args.len()) {
+        analyzer.add_assoc_entity_dep(dep, *arg);
+      }
+    }
+  }
 }
 
 #[derive(Debug)]
@@ -284,17 +318,7 @@ impl<'a> FnCache<'a> {
       let ret = analyzer.factory.computed(cached.ret, call_dep);
       let has_global_effects = cached.has_global_effects;
       drop(table);
-
-      analyzer.add_assoc_dep(track_deps.call_id, call_dep);
-
-      analyzer.add_assoc_entity_dep(track_deps.this, this);
-      for (dep, arg) in track_deps.args.iter().zip(args.elements.iter()) {
-        analyzer.add_assoc_entity_dep(*dep, *arg);
-      }
-      for (dep, rest) in track_deps.rest.iter().zip(args.rest.iter()) {
-        analyzer.add_assoc_entity_dep(*dep, *rest);
-      }
-
+      track_deps.assoc(analyzer, call_dep, this, &args);
       if has_global_effects {
         analyzer.global_effect();
       }

crates/jsshaker/src/value/function/call.rs

@@ -47,7 +47,7 @@ impl<'a> FunctionValue<'a> {
       {
         return cached_ret;
       } else {
-        Some(FnCacheTrackDeps::wrap(analyzer, call_id, &mut this, &mut args))
+        Some(FnCacheTrackDeps::wrap::<false>(analyzer, call_id, &mut this, &mut args))
       }
     } else {
       None

crates/jsshaker/src/value/function/mod.rs

@@ -16,11 +16,11 @@ use super::{
 use crate::{
   analyzer::Analyzer,
   builtin_string,
-  dep::{Dep, LazyDep},
+  dep::{Dep, DepAtom},
   entity::Entity,
   scope::VariableScopeId,
   utils::{CalleeInfo, CalleeNode},
-  value::cache::FnCache,
+  value::cache::{FnCache, FnCacheTrackDeps},
 };
 pub use arguments::*;
 pub use builtin::*;
@@ -33,15 +33,14 @@ pub struct FunctionValue<'a> {
   pub finite_recursion: bool,
   pub statics: &'a ObjectValue<'a>,
 
-  // Workaround: The lazy dep of `this` value
-  body_consumed: Cell<Option<LazyDep<'a, Entity<'a>>>>,
+  body_consumed: Cell<Option<&'a FnCacheTrackDeps<'a>>>,
 
   cache: FnCache<'a>,
 }
 
 impl<'a> ValueTrait<'a> for FunctionValue<'a> {
   fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
-    self.consume_body(analyzer, analyzer.factory.unknown);
+    self.consume_body(analyzer, analyzer.factory.unknown, analyzer.factory.unknown_arguments);
     self.statics.consume(analyzer);
   }
 
@@ -88,14 +87,16 @@ impl<'a> ValueTrait<'a> for FunctionValue<'a> {
     this: Entity<'a>,
     args: ArgumentsValue<'a>,
   ) -> Entity<'a> {
-    if let Some(this_dep) = self.body_consumed.get() {
-      this_dep.push(analyzer, this);
-      return consumed_object::call(self, analyzer, dep, analyzer.factory.unknown, args);
+    if let Some(track_deps) = self.body_consumed.get() {
+      analyzer.global_effect();
+      track_deps.assoc(analyzer, dep, this, &args);
+      return analyzer.factory.unknown;
     }
 
     if self.check_recursion(analyzer) {
-      self.consume_body(analyzer, this);
-      return consumed_object::call(self, analyzer, dep, analyzer.factory.unknown, args);
+      analyzer.global_effect();
+      analyzer.consume(dep);
+      return self.consume_body(analyzer, this, args);
     }
 
     self.call_impl::<false>(analyzer, dep, this, args, false)
@@ -107,13 +108,16 @@ impl<'a> ValueTrait<'a> for FunctionValue<'a> {
     dep: Dep<'a>,
     args: ArgumentsValue<'a>,
   ) -> Entity<'a> {
-    if self.body_consumed.get().is_some() {
-      return consumed_object::construct(self, analyzer, dep, args);
+    if let Some(track_deps) = self.body_consumed.get() {
+      analyzer.global_effect();
+      track_deps.assoc(analyzer, dep, analyzer.factory.unknown, &args);
+      return analyzer.factory.unknown;
     }
 
     if self.check_recursion(analyzer) {
-      self.consume_body(analyzer, analyzer.factory.unknown);
-      return consumed_object::construct(self, analyzer, dep, args);
+      analyzer.global_effect();
+      analyzer.consume(dep);
+      return self.consume_body(analyzer, analyzer.factory.unknown, args);
     }
 
     self.construct_impl(analyzer, dep, args, false)
@@ -215,14 +219,19 @@ impl<'a> FunctionValue<'a> {
     false
   }
 
-  pub fn consume_body(&'a self, analyzer: &mut Analyzer<'a>, this: Entity<'a>) {
+  pub fn consume_body(
+    &'a self,
+    analyzer: &mut Analyzer<'a>,
+    mut this: Entity<'a>,
+    mut args: ArgumentsValue<'a>,
+  ) -> Entity<'a> {
     if self.body_consumed.get().is_some() {
-      return;
+      return analyzer.factory.unknown;
     }
 
-    let this_dep = analyzer.factory.lazy_dep(analyzer.factory.vec1(this));
-    let this = analyzer.factory.computed_unknown(this_dep);
-    self.body_consumed.set(Some(this_dep));
+    let track_deps =
+      FnCacheTrackDeps::wrap::<true>(analyzer, DepAtom::placeholder(), &mut this, &mut args);
+    self.body_consumed.set(Some(analyzer.allocator.alloc(track_deps)));
 
     analyzer.consume(self.callee.into_node());
 
@@ -232,14 +241,8 @@ impl<'a> FunctionValue<'a> {
     let name = "";
 
     analyzer.exec_consumed_fn(name, move |analyzer| {
-      self.call_impl::<false>(
-        analyzer,
-        analyzer.factory.no_dep,
-        this,
-        analyzer.factory.unknown_arguments,
-        true,
-      )
-    });
+      self.call_impl::<false>(analyzer, analyzer.factory.no_dep, this, args, true)
+    })
   }
 }
 
@@ -267,7 +270,7 @@ impl<'a> Analyzer<'a> {
     }
 
     if created_in_self {
-      function.consume_body(self, self.factory.unknown);
+      function.consume_body(self, self.factory.unknown, self.factory.unknown_arguments);
     }
 
     (function, prototype)

crates/jsshaker/tests/fixtures/recursion.js

@@ -17,12 +17,13 @@ export function simple() {
 }
 
 export function complex1() {
-  function main(a) {
-    return () => g(a)
+  function main(a, b) {
+    console.log(a)
+    return () => g(a, b)
   }
 
-  function g(a) {
-    return () => main(a + 1)
+  function g(a, b) {
+    return () => main(a + 1, b * 2)
   }
 
   t = main(1)