fixup

Author: kermanx

crates/tree_shaker/src/consumable/mod.rs

@@ -3,7 +3,7 @@ mod impls;
 mod lazy;
 mod once;
 
-use crate::{analyzer::Analyzer, entity::Entity};
+use crate::analyzer::Analyzer;
 pub use collector::*;
 pub use lazy::*;
 pub use once::*;

crates/tree_shaker/src/entity/arguments.rs

@@ -2,11 +2,7 @@ use super::{
   consumed_object, Entity, EnumeratedProperties, IteratedElements, ObjectPrototype, TypeofResult,
   ValueTrait,
 };
-use crate::{
-  analyzer::Analyzer,
-  consumable::{Consumable, ConsumableTrait},
-  use_consumed_flag,
-};
+use crate::{analyzer::Analyzer, consumable::Consumable, use_consumed_flag};
 use std::cell::Cell;
 
 #[derive(Debug, Default)]
@@ -15,17 +11,15 @@ pub struct ArgumentsEntity<'a> {
   pub arguments: Vec<(bool, Entity<'a>)>,
 }
 
-impl<'a> ConsumableTrait<'a> for ArgumentsEntity<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
+impl<'a> ValueTrait<'a> for ArgumentsEntity<'a> {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
     use_consumed_flag!(self);
 
     for (_, entity) in &self.arguments {
       entity.consume(analyzer);
     }
   }
-}
 
-impl<'a> ValueTrait<'a> for ArgumentsEntity<'a> {
   fn unknown_mutate(&'a self, analyzer: &mut Analyzer<'a>, dep: Consumable<'a>) {
     if self.consumed.get() {
       return consumed_object::unknown_mutate(analyzer, dep);

crates/tree_shaker/src/entity/array.rs

@@ -4,7 +4,7 @@ use super::{
 };
 use crate::{
   analyzer::Analyzer,
-  consumable::{Consumable, ConsumableCollector, ConsumableTrait},
+  consumable::{Consumable, ConsumableCollector},
   scope::CfScopeId,
   use_consumed_flag,
 };
@@ -33,8 +33,8 @@ impl<'a> fmt::Debug for ArrayEntity<'a> {
   }
 }
 
-impl<'a> ConsumableTrait<'a> for ArrayEntity<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
+impl<'a> ValueTrait<'a> for ArrayEntity<'a> {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
     use_consumed_flag!(self);
 
     analyzer.mark_object_consumed(self.cf_scope, self.object_id);
@@ -44,9 +44,7 @@ impl<'a> ConsumableTrait<'a> for ArrayEntity<'a> {
     analyzer.consume(self.elements.take());
     analyzer.consume(self.rest.take());
   }
-}
 
-impl<'a> ValueTrait<'a> for ArrayEntity<'a> {
   fn unknown_mutate(&'a self, analyzer: &mut Analyzer<'a>, dep: Consumable<'a>) {
     if self.consumed.get() {
       return consumed_object::unknown_mutate(analyzer, dep);

crates/tree_shaker/src/entity/builtin_fn.rs

@@ -2,13 +2,10 @@ use super::{
   consumed_object, never::NeverEntity, Entity, EntityFactory, EnumeratedProperties,
   IteratedElements, ObjectEntity, ObjectPrototype, TypeofResult, ValueTrait,
 };
-use crate::{
-  analyzer::Analyzer,
-  consumable::{Consumable, ConsumableTrait},
-};
+use crate::{analyzer::Analyzer, consumable::Consumable};
 use std::fmt::Debug;
 
-trait BuiltinFnEntity<'a>: ConsumableTrait<'a> {
+trait BuiltinFnEntity<'a>: Debug {
   #[cfg(feature = "flame")]
   fn name(&self) -> &'static str;
   fn object(&self) -> Option<&'a ObjectEntity<'a>> {
@@ -24,6 +21,12 @@ trait BuiltinFnEntity<'a>: ConsumableTrait<'a> {
 }
 
 impl<'a, T: BuiltinFnEntity<'a>> ValueTrait<'a> for T {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
+    if let Some(object) = self.object() {
+      object.consume(analyzer);
+    }
+  }
+
   fn unknown_mutate(&'a self, _analyzer: &mut Analyzer<'a>, _dep: Consumable<'a>) {
     // No effect
   }
@@ -191,16 +194,6 @@ impl<'a, F: BuiltinFnImplementation<'a> + 'a> Debug for ImplementedBuiltinFnEnti
   }
 }
 
-impl<'a, F: BuiltinFnImplementation<'a> + 'a> ConsumableTrait<'a>
-  for ImplementedBuiltinFnEntity<'a, F>
-{
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
-    if let Some(object) = self.object() {
-      object.consume(analyzer);
-    }
-  }
-}
-
 impl<'a, F: BuiltinFnImplementation<'a> + 'a> BuiltinFnEntity<'a>
   for ImplementedBuiltinFnEntity<'a, F>
 {
@@ -245,14 +238,6 @@ pub struct PureBuiltinFnEntity<'a> {
   return_value: fn(&EntityFactory<'a>) -> Entity<'a>,
 }
 
-impl<'a> ConsumableTrait<'a> for PureBuiltinFnEntity<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
-    if let Some(object) = self.object() {
-      object.consume(analyzer);
-    }
-  }
-}
-
 impl<'a> BuiltinFnEntity<'a> for PureBuiltinFnEntity<'a> {
   #[cfg(feature = "flame")]
   fn name(&self) -> &'static str {

crates/tree_shaker/src/entity/class.rs

@@ -4,14 +4,14 @@ use super::{
 };
 use crate::{
   analyzer::Analyzer,
-  consumable::{Consumable, ConsumableTrait},
+  consumable::Consumable,
   scope::VariableScopeId,
   utils::{CalleeInfo, CalleeNode},
 };
 use oxc::span::GetSpan;
 use std::{cell::Cell, rc::Rc};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FunctionEntity<'a> {
   body_consumed: Rc<Cell<bool>>,
   pub callee: CalleeInfo<'a>,
@@ -22,15 +22,13 @@ pub struct FunctionEntity<'a> {
   pub prototype: &'a ObjectEntity<'a>,
 }
 
-impl<'a> ConsumableTrait<'a> for FunctionEntity<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
-    (analyzer.allocator.alloc(self.clone())).consume_body(analyzer);
+impl<'a> ValueTrait<'a> for FunctionEntity<'a> {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
+    self.consume_body(analyzer);
     self.statics.consume(analyzer);
     self.prototype.consume(analyzer);
   }
-}
 
-impl<'a> ValueTrait<'a> for FunctionEntity<'a> {
   fn unknown_mutate(&'a self, analyzer: &mut Analyzer<'a>, dep: Consumable<'a>) {
     self.consume(analyzer);
     consumed_object::unknown_mutate(analyzer, dep);

crates/tree_shaker/src/entity/function.rs

@@ -5,7 +5,7 @@ use super::{
 use crate::{
   analyzer::Analyzer,
   builtins::BuiltinPrototype,
-  consumable::{Consumable, ConsumableTrait},
+  consumable::Consumable,
   mangling::{MangleAtom, MangleConstraint},
   transformer::Transformer,
   utils::F64WithEq,
@@ -33,15 +33,13 @@ pub enum LiteralEntity<'a> {
   Undefined,
 }
 
-impl<'a> ConsumableTrait<'a> for LiteralEntity<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
+impl<'a> ValueTrait<'a> for LiteralEntity<'a> {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
     if let LiteralEntity::String(_, Some(atom)) = self {
       analyzer.consume(*atom);
     }
   }
-}
 
-impl<'a> ValueTrait<'a> for LiteralEntity<'a> {
   fn consume_mangable(&'a self, _analyzer: &mut Analyzer<'a>) -> bool {
     // No effect
     !matches!(self, LiteralEntity::String(_, Some(_)))

crates/tree_shaker/src/entity/literal.rs

@@ -1,10 +1,7 @@
 use super::{
   Entity, EnumeratedProperties, IteratedElements, ObjectPrototype, TypeofResult, ValueTrait,
 };
-use crate::{
-  analyzer::Analyzer,
-  consumable::{Consumable, ConsumableTrait},
-};
+use crate::{analyzer::Analyzer, consumable::Consumable};
 
 #[derive(Debug, Clone)]
 pub struct LogicalResultEntity<'a> {
@@ -13,13 +10,11 @@ pub struct LogicalResultEntity<'a> {
   pub result: Option<bool>,
 }
 
-impl<'a> ConsumableTrait<'a> for LogicalResultEntity<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
+impl<'a> ValueTrait<'a> for LogicalResultEntity<'a> {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
     self.value.consume(analyzer);
   }
-}
 
-impl<'a> ValueTrait<'a> for LogicalResultEntity<'a> {
   fn consume_mangable(&'a self, analyzer: &mut Analyzer<'a>) -> bool {
     self.value.consume_mangable(analyzer)
   }

crates/tree_shaker/src/entity/logical_result.rs

@@ -38,7 +38,8 @@ pub type EnumeratedProperties<'a> = (Vec<(bool, Entity<'a>, Entity<'a>)>, Consum
 /// (vec![known_elements], rest, dep)
 pub type IteratedElements<'a> = (Vec<Entity<'a>>, Option<Entity<'a>>, Consumable<'a>);
 
-pub trait ValueTrait<'a>: ConsumableTrait<'a> {
+pub trait ValueTrait<'a>: Debug {
+  fn consume(&'a self, analyzer: &mut Analyzer<'a>);
   /// Returns true if the entity is completely consumed
   fn consume_mangable(&'a self, analyzer: &mut Analyzer<'a>) -> bool {
     self.consume(analyzer);