chore: remove get_destructable

kermanx · kermanx · commit b1f737833f51 · 2025-03-21T11:51:21.000+08:00
diff --git a/crates/tree_shaker/src/builtins/globals/object_constructor.rs b/crates/tree_shaker/src/builtins/globals/object_constructor.rs
@@ -164,7 +164,12 @@ impl<'a> Builtins<'a> {
             _ => {}
           }
         }
-        object.set_property(analyzer, descriptor.get_destructable(analyzer, dep), key, value);
+        object.set_property(
+          analyzer,
+          analyzer.factory.consumable((dep, descriptor.shallow_dep())),
+          key,
+          value,
+        );
         return object;
       }
 
diff --git a/crates/tree_shaker/src/builtins/react/jsxs.rs b/crates/tree_shaker/src/builtins/react/jsxs.rs
@@ -4,7 +4,7 @@ pub fn create_react_jsxs_impl<'a>(factory: &'a EntityFactory<'a>) -> Entity<'a>
   factory.implemented_builtin_fn("React::jsxs", |analyzer, dep, _this, args| {
     let args = args.destruct_as_array(analyzer, dep, 3, false).0;
     let [tag, props, key] = args[..] else { unreachable!() };
-    analyzer.consume(props.get_destructable(analyzer, analyzer.factory.empty_consumable));
+    analyzer.consume(props.shallow_dep());
     props.set_property(
       analyzer,
       analyzer.factory.empty_consumable,
diff --git a/crates/tree_shaker/src/entity/arguments.rs b/crates/tree_shaker/src/entity/arguments.rs
@@ -114,10 +114,6 @@ impl<'a> ValueTrait<'a> for ArgumentsEntity<'a> {
     (elements, rest.map(|val| analyzer.factory.union(val)), dep)
   }
 
-  fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, _dep: Consumable<'a>) -> Consumable<'a> {
-    unreachable!()
-  }
-
   fn get_typeof(&'a self, _analyzer: &Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
diff --git a/crates/tree_shaker/src/entity/array.rs b/crates/tree_shaker/src/entity/array.rs
@@ -311,10 +311,6 @@ impl<'a> ValueTrait<'a> for ArrayEntity<'a> {
     )
   }
 
-  fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    dep
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("object")
   }
diff --git a/crates/tree_shaker/src/entity/builtin_fn.rs b/crates/tree_shaker/src/entity/builtin_fn.rs
@@ -121,10 +121,6 @@ impl<'a, T: BuiltinFnEntity<'a>> ValueTrait<'a> for T {
     }
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    analyzer.consumable((self, dep))
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("function")
   }
diff --git a/crates/tree_shaker/src/entity/function.rs b/crates/tree_shaker/src/entity/function.rs
@@ -128,10 +128,6 @@ impl<'a> ValueTrait<'a> for FunctionEntity<'a> {
     consumed_object::iterate(analyzer, dep)
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    analyzer.consumable((self, dep))
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("function")
   }
diff --git a/crates/tree_shaker/src/entity/literal.rs b/crates/tree_shaker/src/entity/literal.rs
@@ -197,10 +197,6 @@ impl<'a> ValueTrait<'a> for LiteralEntity<'a> {
     }
   }
 
-  fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    dep
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string(self.test_typeof().to_string().unwrap())
   }
diff --git a/crates/tree_shaker/src/entity/logical_result.rs b/crates/tree_shaker/src/entity/logical_result.rs
@@ -85,10 +85,6 @@ impl<'a> ValueTrait<'a> for LogicalResultEntity<'a> {
     self.value.iterate(analyzer, dep)
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    self.value.get_destructable(analyzer, dep)
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     self.value.get_typeof(analyzer)
   }
diff --git a/crates/tree_shaker/src/entity/mod.rs b/crates/tree_shaker/src/entity/mod.rs
@@ -83,7 +83,6 @@ pub trait ValueTrait<'a>: Debug {
   fn r#await(&'a self, analyzer: &mut Analyzer<'a>, dep: Consumable<'a>) -> Entity<'a>;
   fn iterate(&'a self, analyzer: &mut Analyzer<'a>, dep: Consumable<'a>) -> IteratedElements<'a>;
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a>;
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a>;
   fn get_to_string(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a>;
   fn get_to_numeric(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a>;
@@ -216,6 +215,10 @@ pub struct Entity<'a> {
 }
 
 impl<'a> Entity<'a> {
+  pub fn shallow_dep(&self) -> Option<Consumable<'a>> {
+    self.dep
+  }
+
   fn forward_dep(
     &self,
     dep: impl ConsumeTrait<'a> + 'a,
@@ -319,13 +322,6 @@ impl<'a> Entity<'a> {
   ) -> IteratedElements<'a> {
     self.value.iterate(analyzer, self.forward_dep(dep, analyzer))
   }
-  pub fn get_destructable(
-    &self,
-    analyzer: &Analyzer<'a>,
-    dep: impl ConsumeTrait<'a> + 'a,
-  ) -> Consumable<'a> {
-    self.value.get_destructable(analyzer, self.forward_dep(dep, analyzer))
-  }
   pub fn get_typeof(&self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     self.forward_value(self.value.get_typeof(analyzer), analyzer)
   }
diff --git a/crates/tree_shaker/src/entity/never.rs b/crates/tree_shaker/src/entity/never.rs
@@ -71,9 +71,6 @@ impl<'a> ValueTrait<'a> for NeverEntity {
     (Vec::new(), None, analyzer.factory.empty_consumable)
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, _dep: Consumable<'a>) -> Consumable<'a> {
-    analyzer.factory.empty_consumable
-  }
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.never
   }
diff --git a/crates/tree_shaker/src/entity/object/mod.rs b/crates/tree_shaker/src/entity/object/mod.rs
@@ -161,10 +161,6 @@ impl<'a> ValueTrait<'a> for ObjectEntity<'a> {
     consumed_object::iterate(analyzer, dep)
   }
 
-  fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    dep
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("object")
   }
diff --git a/crates/tree_shaker/src/entity/primitive.rs b/crates/tree_shaker/src/entity/primitive.rs
@@ -121,10 +121,6 @@ impl<'a> ValueTrait<'a> for PrimitiveEntity {
     }
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    analyzer.consumable((self, dep))
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     if let Some(str) = self.test_typeof().to_string() {
       analyzer.factory.string(str)
diff --git a/crates/tree_shaker/src/entity/react_element.rs b/crates/tree_shaker/src/entity/react_element.rs
@@ -126,10 +126,6 @@ impl<'a> ValueTrait<'a> for ReactElementEntity<'a> {
     consumed_object::iterate(analyzer, dep)
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    analyzer.consumable((self, dep))
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.computed_unknown_string(self)
   }
diff --git a/crates/tree_shaker/src/entity/union.rs b/crates/tree_shaker/src/entity/union.rs
@@ -137,14 +137,6 @@ impl<'a, V: UnionLike<'a, Entity<'a>> + Debug + 'a> ValueTrait<'a> for UnionEnti
     (vec![], analyzer.factory.try_union(results), analyzer.factory.empty_consumable)
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    let mut values = Vec::new();
-    for entity in self.values.iter() {
-      values.push(entity.get_destructable(analyzer, dep));
-    }
-    analyzer.consumable(values)
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     // TODO: collect literals
     let values = self.values.map(|v| v.get_typeof(analyzer));
diff --git a/crates/tree_shaker/src/entity/unknown.rs b/crates/tree_shaker/src/entity/unknown.rs
@@ -83,10 +83,6 @@ impl<'a> ValueTrait<'a> for UnknownEntity<'a> {
     consumed_object::iterate(analyzer, dep)
   }
 
-  fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {
-    analyzer.consumable((self, dep))
-  }
-
   fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.computed_unknown_string(self)
   }
diff --git a/crates/tree_shaker/src/nodes/misc/assignment_target_pattern.rs b/crates/tree_shaker/src/nodes/misc/assignment_target_pattern.rs
@@ -28,7 +28,7 @@ impl<'a> Analyzer<'a> {
         self.pop_cf_scope();
       }
       AssignmentTargetPattern::ObjectAssignmentTarget(node) => {
-        self.push_dependent_cf_scope(value.get_destructable(self, self.factory.empty_consumable));
+        self.push_dependent_cf_scope(value.shallow_dep());
 
         let is_nullish = value.test_nullish();
         if is_nullish != Some(false) {
diff --git a/crates/tree_shaker/src/nodes/stmt/for_in_statement.rs b/crates/tree_shaker/src/nodes/stmt/for_in_statement.rs
@@ -9,7 +9,7 @@ impl<'a> Analyzer<'a> {
     let right = self.exec_expression(&node.right);
 
     if let Some(keys) = right.get_own_keys(self) {
-      let dep = right.get_destructable(self, AstKind2::ForInStatement(node));
+      let dep = self.factory.consumable((right.shallow_dep(), AstKind2::ForInStatement(node)));
       self.push_cf_scope_with_deps(CfScopeKind::LoopBreak, vec![dep], Some(false));
       for (definite, key) in keys {
         self.push_cf_scope_with_deps(
diff --git a/crates/tree_shaker/src/scope/call_scope.rs b/crates/tree_shaker/src/scope/call_scope.rs
@@ -61,9 +61,7 @@ impl<'a> CallScope<'a> {
         if !try_scope.thrown_values.is_empty() {
           parent_try_scope.thrown_values.push(unknown);
         }
-        for value in try_scope.thrown_values {
-          value.consume(analyzer);
-        }
+        analyzer.consume(try_scope.thrown_values);
       } else if self.is_async {
         promise_error = Some(try_scope.thrown_values);
       } else {

Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,12 @@ impl<'a> Builtins<'a> {`
`164`	`164`	`_ => {}`
`165`	`165`	`}`
`166`	`166`	`}`
`167`		`- object.set_property(analyzer, descriptor.get_destructable(analyzer, dep), key, value);`
	`167`	`+ object.set_property(`
	`168`	`+ analyzer,`
	`169`	`+ analyzer.factory.consumable((dep, descriptor.shallow_dep())),`
	`170`	`+ key,`
	`171`	`+ value,`
	`172`	`+ );`
`168`	`173`	`return object;`
`169`	`174`	`}`
`170`	`175`
Original file line number	Diff line number	Diff line change
`@@ -114,10 +114,6 @@ impl<'a> ValueTrait<'a> for ArgumentsEntity<'a> {`
`114`	`114`	`(elements, rest.map(\|val\| analyzer.factory.union(val)), dep)`
`115`	`115`	`}`
`116`	`116`
`117`		`- fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, _dep: Consumable<'a>) -> Consumable<'a> {`
`118`		`- unreachable!()`
`119`		`- }`
`120`		`-`
`121`	`117`	`fn get_typeof(&'a self, _analyzer: &Analyzer<'a>) -> Entity<'a> {`
`122`	`118`	`unreachable!()`
`123`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -311,10 +311,6 @@ impl<'a> ValueTrait<'a> for ArrayEntity<'a> {`
`311`	`311`	`)`
`312`	`312`	`}`
`313`	`313`
`314`		`- fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`315`		`- dep`
`316`		`- }`
`317`		`-`
`318`	`314`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`319`	`315`	`analyzer.factory.string("object")`
`320`	`316`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,10 +121,6 @@ impl<'a, T: BuiltinFnEntity<'a>> ValueTrait<'a> for T {`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`- fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`125`		`- analyzer.consumable((self, dep))`
`126`		`- }`
`127`		`-`
`128`	`124`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`129`	`125`	`analyzer.factory.string("function")`
`130`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,10 +128,6 @@ impl<'a> ValueTrait<'a> for FunctionEntity<'a> {`
`128`	`128`	`consumed_object::iterate(analyzer, dep)`
`129`	`129`	`}`
`130`	`130`
`131`		`- fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`132`		`- analyzer.consumable((self, dep))`
`133`		`- }`
`134`		`-`
`135`	`131`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`136`	`132`	`analyzer.factory.string("function")`
`137`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -197,10 +197,6 @@ impl<'a> ValueTrait<'a> for LiteralEntity<'a> {`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`
`200`		`- fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`201`		`- dep`
`202`		`- }`
`203`		`-`
`204`	`200`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`205`	`201`	`analyzer.factory.string(self.test_typeof().to_string().unwrap())`
`206`	`202`	`}`
Original file line number	Diff line number	Diff line change
`@@ -85,10 +85,6 @@ impl<'a> ValueTrait<'a> for LogicalResultEntity<'a> {`
`85`	`85`	`self.value.iterate(analyzer, dep)`
`86`	`86`	`}`
`87`	`87`
`88`		`- fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`89`		`- self.value.get_destructable(analyzer, dep)`
`90`		`- }`
`91`		`-`
`92`	`88`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`93`	`89`	`self.value.get_typeof(analyzer)`
`94`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,9 +71,6 @@ impl<'a> ValueTrait<'a> for NeverEntity {`
`71`	`71`	`(Vec::new(), None, analyzer.factory.empty_consumable)`
`72`	`72`	`}`
`73`	`73`
`74`		`- fn get_destructable(&'a self, analyzer: &Analyzer<'a>, _dep: Consumable<'a>) -> Consumable<'a> {`
`75`		`- analyzer.factory.empty_consumable`
`76`		`- }`
`77`	`74`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`78`	`75`	`analyzer.factory.never`
`79`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -161,10 +161,6 @@ impl<'a> ValueTrait<'a> for ObjectEntity<'a> {`
`161`	`161`	`consumed_object::iterate(analyzer, dep)`
`162`	`162`	`}`
`163`	`163`
`164`		`- fn get_destructable(&'a self, _analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`165`		`- dep`
`166`		`- }`
`167`		`-`
`168`	`164`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`169`	`165`	`analyzer.factory.string("object")`
`170`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,10 +121,6 @@ impl<'a> ValueTrait<'a> for PrimitiveEntity {`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`- fn get_destructable(&'a self, analyzer: &Analyzer<'a>, dep: Consumable<'a>) -> Consumable<'a> {`
`125`		`- analyzer.consumable((self, dep))`
`126`		`- }`
`127`		`-`
`128`	`124`	`fn get_typeof(&'a self, analyzer: &Analyzer<'a>) -> Entity<'a> {`
`129`	`125`	`if let Some(str) = self.test_typeof().to_string() {`
`130`	`126`	`analyzer.factory.string(str)`