refactor: entity and value (#46)

Author: kermanx

crates/tree_shaker/src/builtins/globals/object_constructor.rs

@@ -26,7 +26,7 @@ impl<'a> Builtins<'a> {
       "defineProperty" => self.create_object_define_property_impl(),
     });
 
-    self.globals.borrow_mut().insert("Object", object);
+    self.globals.borrow_mut().insert("Object", object.into());
   }
 
   fn create_object_assign_impl(&self) -> Entity<'a> {
@@ -76,7 +76,7 @@ impl<'a> Builtins<'a> {
         }
       }
 
-      analyzer.factory.computed(array, deps)
+      analyzer.factory.computed(array.into(), deps)
     })
   }
 
@@ -91,7 +91,7 @@ impl<'a> Builtins<'a> {
         array.init_rest(value);
       }
 
-      analyzer.factory.computed(array, deps)
+      analyzer.factory.computed(array.into(), deps)
     })
   }
 
@@ -106,10 +106,10 @@ impl<'a> Builtins<'a> {
         let entry = analyzer.new_empty_array();
         entry.push_element(key.get_to_string(analyzer));
         entry.push_element(value);
-        array.init_rest(entry);
+        array.init_rest(entry.into());
       }
 
-      analyzer.factory.computed(array, deps)
+      analyzer.factory.computed(array.into(), deps)
     })
   }
 
@@ -168,8 +168,7 @@ impl<'a> Builtins<'a> {
         return object;
       }
 
-      let dep = analyzer.factory.consumable((dep, key, descriptor));
-      object.unknown_mutate(analyzer, dep);
+      object.unknown_mutate(analyzer, (dep, key, descriptor));
       object
     })
   }

crates/tree_shaker/src/builtins/globals/symbol_constructor.rs

@@ -34,6 +34,6 @@ impl<'a> Builtins<'a> {
       // "toString" => factory.string("__#toString__"),
     });
 
-    self.globals.borrow_mut().insert("Symbol", object);
+    self.globals.borrow_mut().insert("Symbol", object.into());
   }
 }

crates/tree_shaker/src/builtins/import_meta.rs

@@ -31,6 +31,6 @@ impl<'a> Builtins<'a> {
       },
     );
 
-    object
+    object.into()
   }
 }

crates/tree_shaker/src/builtins/prototypes/function.rs

@@ -1,6 +1,6 @@
 use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{
-  entity::{Entity, EntityFactory, ObjectId},
+  entity::{EntityFactory, ObjectId},
   init_prototype,
 };
 
@@ -14,11 +14,11 @@ pub fn create_function_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinProt
         // This can be any value
         let arguments_object_id = ObjectId::from_usize(0);
         match arg.test_is_undefined() {
-          Some(true) => analyzer.factory.array(cf_scope, arguments_object_id),
+          Some(true) => analyzer.factory.array(cf_scope, arguments_object_id).into(),
           Some(false) => arg,
           None => analyzer.factory.union((
             arg,
-            analyzer.factory.array(cf_scope, arguments_object_id) as Entity<'a>,
+            analyzer.factory.array(cf_scope, arguments_object_id).into(),
           )),
         }
       };

crates/tree_shaker/src/builtins/prototypes/mod.rs

@@ -73,7 +73,7 @@ impl<'a> BuiltinPrototype<'a> {
     key: Entity<'a>,
     dep: Consumable<'a>,
   ) -> Entity<'a> {
-    let dep = analyzer.consumable((dep, target, key));
+    let dep = (dep, target, key);
     if let Some(key_literals) = key.get_to_literals(analyzer) {
       let mut values = vec![];
       for key_literal in key_literals {

crates/tree_shaker/src/builtins/react/class_names.rs

@@ -28,6 +28,6 @@ pub fn create_class_names_namespace<'a>(
       }
     }
 
-    analyzer.factory.computed_unknown_string(analyzer.consumable((deps_1, deps_2, rest)))
+    analyzer.factory.computed_unknown_string((deps_1, deps_2, rest))
   })
 }

crates/tree_shaker/src/builtins/react/context.rs

@@ -60,7 +60,7 @@ pub fn create_react_create_context_impl<'a>(factory: &'a EntityFactory<'a>) -> E
       "Consumer" => create_react_context_consumer_impl(analyzer, context_id),
     });
 
-    context
+    context.into()
   })
 }
 

crates/tree_shaker/src/builtins/react/create_element.rs

@@ -6,13 +6,14 @@ pub fn create_react_create_element_impl<'a>(factory: &'a EntityFactory<'a>) -> E
     let [tag, props] = args[..] else { unreachable!() };
     let props = match props.test_nullish() {
       Some(true) => analyzer
-        .new_empty_object(ObjectPrototype::Builtin(&analyzer.builtins.prototypes.object), None),
+        .new_empty_object(ObjectPrototype::Builtin(&analyzer.builtins.prototypes.object), None)
+        .into(),
       Some(false) => props,
       None => analyzer.factory.union((
         props,
         analyzer
           .new_empty_object(ObjectPrototype::Builtin(&analyzer.builtins.prototypes.object), None)
-          as Entity<'a>,
+          .into(),
       )),
     };
 

crates/tree_shaker/src/builtins/react/mod.rs

@@ -51,7 +51,7 @@ pub fn create_react_namespace<'a>(
     "useMemo" => create_react_use_memo_impl(factory),
   });
 
-  namespace
+  namespace.into()
 }
 
 pub fn create_react_jsx_runtime_namespace<'a>(
@@ -70,5 +70,5 @@ pub fn create_react_jsx_runtime_namespace<'a>(
     "jsxs" => create_react_jsxs_impl(factory),
   });
 
-  object
+  object.into()
 }

crates/tree_shaker/src/consumable/collector.rs

@@ -1,20 +1,20 @@
-use super::{Consumable, ConsumableTrait};
+use super::{Consumable, ConsumeTrait};
 use crate::{analyzer::Analyzer, entity::EntityFactory};
 use std::mem;
 
 #[derive(Debug)]
-pub struct ConsumableCollector<'a, T: ConsumableTrait<'a> + 'a = Consumable<'a>> {
+pub struct ConsumableCollector<'a, T: ConsumeTrait<'a> + 'a = Consumable<'a>> {
   pub current: Vec<T>,
   pub node: Option<Consumable<'a>>,
 }
 
-impl<'a, T: ConsumableTrait<'a> + 'a> Default for ConsumableCollector<'a, T> {
+impl<'a, T: ConsumeTrait<'a> + 'a> Default for ConsumableCollector<'a, T> {
   fn default() -> Self {
     Self { current: Vec::new(), node: None }
   }
 }
 
-impl<'a, T: ConsumableTrait<'a> + 'a> ConsumableCollector<'a, T> {
+impl<'a, T: ConsumeTrait<'a> + 'a> ConsumableCollector<'a, T> {
   pub fn new(current: Vec<T>) -> Self {
     Self { current, node: None }
   }

crates/tree_shaker/src/consumable/impls.rs

@@ -1,66 +1,54 @@
-use super::{Consumable, ConsumableTrait};
+use super::{ConsumableTrait, ConsumeTrait};
 use crate::analyzer::Analyzer;
 use std::{cell::RefCell, rc::Rc};
 
 impl<'a> ConsumableTrait<'a> for () {
   fn consume(&self, _: &mut Analyzer<'a>) {}
 }
 
-impl<'a, T: ConsumableTrait<'a> + 'a> ConsumableTrait<'a> for Box<T> {
+impl<'a, T: ConsumeTrait<'a> + 'a> ConsumableTrait<'a> for Box<T> {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     self.as_ref().consume(analyzer)
   }
 }
 
-impl<'a, T: ConsumableTrait<'a> + 'a> ConsumableTrait<'a> for Option<T> {
+impl<'a, T: ConsumeTrait<'a> + 'a> ConsumableTrait<'a> for Option<T> {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     if let Some(value) = self {
       value.consume(analyzer)
     }
   }
 }
 
-impl<'a, T: Default + ConsumableTrait<'a> + 'a> ConsumableTrait<'a> for &'a RefCell<T> {
+impl<'a, T: Default + ConsumeTrait<'a> + 'a> ConsumableTrait<'a> for &'a RefCell<T> {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     self.take().consume(analyzer)
   }
 }
 
-impl<'a, T: Default + ConsumableTrait<'a> + 'a> ConsumableTrait<'a> for Rc<T> {
+impl<'a, T: Default + ConsumeTrait<'a> + 'a> ConsumableTrait<'a> for Rc<T> {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     self.as_ref().consume(analyzer)
   }
 }
 
-impl<'a> ConsumableTrait<'a> for Consumable<'a> {
-  fn consume(&self, analyzer: &mut Analyzer<'a>) {
-    self.0.consume(analyzer)
-  }
-}
-
-impl<'a, T: ConsumableTrait<'a> + 'a> ConsumableTrait<'a> for Vec<T> {
+impl<'a, T: ConsumeTrait<'a> + 'a> ConsumableTrait<'a> for Vec<T> {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     for item in self {
       item.consume(analyzer)
     }
   }
 }
 
-impl<'a, T1: ConsumableTrait<'a> + 'a, T2: ConsumableTrait<'a> + 'a> ConsumableTrait<'a>
-  for (T1, T2)
-{
+impl<'a, T1: ConsumeTrait<'a> + 'a, T2: ConsumeTrait<'a> + 'a> ConsumableTrait<'a> for (T1, T2) {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     self.0.consume(analyzer);
     self.1.consume(analyzer)
   }
 }
 
-impl<
-    'a,
-    T1: ConsumableTrait<'a> + 'a,
-    T2: ConsumableTrait<'a> + 'a,
-    T3: ConsumableTrait<'a> + 'a,
-  > ConsumableTrait<'a> for (T1, T2, T3)
+impl<'a, T1: ConsumeTrait<'a> + 'a, T2: ConsumeTrait<'a> + 'a, T3: ConsumeTrait<'a> + 'a>
+  ConsumableTrait<'a> for (T1, T2, T3)
 {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {
     self.0.consume(analyzer);
@@ -71,10 +59,10 @@ impl<
 
 impl<
     'a,
-    T1: ConsumableTrait<'a> + 'a,
-    T2: ConsumableTrait<'a> + 'a,
-    T3: ConsumableTrait<'a> + 'a,
-    T4: ConsumableTrait<'a> + 'a,
+    T1: ConsumeTrait<'a> + 'a,
+    T2: ConsumeTrait<'a> + 'a,
+    T3: ConsumeTrait<'a> + 'a,
+    T4: ConsumeTrait<'a> + 'a,
   > ConsumableTrait<'a> for (T1, T2, T3, T4)
 {
   fn consume(&self, analyzer: &mut Analyzer<'a>) {

crates/tree_shaker/src/consumable/mod.rs

@@ -7,20 +7,44 @@ use crate::analyzer::Analyzer;
 pub use collector::*;
 pub use lazy::*;
 pub use once::*;
+use oxc::allocator::Allocator;
 use std::fmt::Debug;
 
 pub trait ConsumableTrait<'a>: Debug {
   fn consume(&self, analyzer: &mut Analyzer<'a>);
 }
 
+pub trait ConsumeTrait<'a>: Debug {
+  fn consume(&self, analyzer: &mut Analyzer<'a>);
+  fn uniform(self, allocator: &'a Allocator) -> Consumable<'a>;
+}
+
+impl<'a, T: ConsumableTrait<'a> + 'a> ConsumeTrait<'a> for T {
+  fn consume(&self, analyzer: &mut Analyzer<'a>) {
+    self.consume(analyzer);
+  }
+  fn uniform(self, allocator: &'a Allocator) -> Consumable<'a> {
+    Consumable(allocator.alloc(self))
+  }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct Consumable<'a>(pub &'a (dyn ConsumableTrait<'a> + 'a));
 
+impl<'a> ConsumeTrait<'a> for Consumable<'a> {
+  fn consume(&self, analyzer: &mut Analyzer<'a>) {
+    self.0.consume(analyzer);
+  }
+  fn uniform(self, _: &'a Allocator) -> Consumable<'a> {
+    self
+  }
+}
+
 pub type ConsumableVec<'a> = Vec<Consumable<'a>>;
 
 impl<'a> Analyzer<'a> {
   #[inline]
-  pub fn consume(&mut self, dep: impl ConsumableTrait<'a> + 'a) {
+  pub fn consume(&mut self, dep: impl ConsumeTrait<'a> + 'a) {
     dep.consume(self);
   }
 

crates/tree_shaker/src/entity/arguments.rs

@@ -1,6 +1,6 @@
 use super::{
-  consumed_object, Entity, EntityTrait, EnumeratedProperties, IteratedElements, ObjectPrototype,
-  TypeofResult,
+  consumed_object, Entity, EnumeratedProperties, IteratedElements, ObjectPrototype, TypeofResult,
+  ValueTrait,
 };
 use crate::{analyzer::Analyzer, consumable::Consumable, use_consumed_flag};
 use std::cell::Cell;
@@ -11,7 +11,7 @@ pub struct ArgumentsEntity<'a> {
   pub arguments: Vec<(bool, Entity<'a>)>,
 }
 
-impl<'a> EntityTrait<'a> for ArgumentsEntity<'a> {
+impl<'a> ValueTrait<'a> for ArgumentsEntity<'a> {
   fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
     use_consumed_flag!(self);
 

crates/tree_shaker/src/entity/array.rs

@@ -1,6 +1,6 @@
 use super::{
-  consumed_object, Entity, EntityTrait, EnumeratedProperties, IteratedElements, LiteralEntity,
-  ObjectId, TypeofResult,
+  consumed_object, Entity, EnumeratedProperties, IteratedElements, LiteralEntity, ObjectId,
+  TypeofResult, ValueTrait,
 };
 use crate::{
   analyzer::Analyzer,
@@ -33,7 +33,7 @@ impl<'a> fmt::Debug for ArrayEntity<'a> {
   }
 }
 
-impl<'a> EntityTrait<'a> for ArrayEntity<'a> {
+impl<'a> ValueTrait<'a> for ArrayEntity<'a> {
   fn consume(&'a self, analyzer: &mut Analyzer<'a>) {
     use_consumed_flag!(self);
 
@@ -95,7 +95,7 @@ impl<'a> EntityTrait<'a> for ArrayEntity<'a> {
               result.push(self.get_length().map_or_else(
                 || {
                   let dep = self.rest.borrow().clone();
-                  analyzer.factory.computed_unknown_number(analyzer.consumable(dep))
+                  analyzer.factory.computed_unknown_number(dep)
                 },
                 |length| analyzer.factory.number(length as f64, None),
               ));
@@ -112,10 +112,10 @@ impl<'a> EntityTrait<'a> for ArrayEntity<'a> {
       }
       analyzer.factory.computed_union(result, dep)
     } else {
-      analyzer.factory.computed_unknown(analyzer.consumable((
+      analyzer.factory.computed_unknown((
         self.elements.borrow().iter().chain(self.rest.borrow().iter()).cloned().collect::<Vec<_>>(),
         dep,
-      )))
+      ))
     }
   }
 
@@ -290,7 +290,7 @@ impl<'a> EntityTrait<'a> for ArrayEntity<'a> {
     if self.consumed.get() {
       return consumed_object::r#await(analyzer, dep);
     }
-    analyzer.factory.computed(self, dep)
+    analyzer.factory.computed(self.into(), dep)
   }
 
   fn iterate(&'a self, analyzer: &mut Analyzer<'a>, dep: Consumable<'a>) -> IteratedElements<'a> {
@@ -342,7 +342,7 @@ impl<'a> EntityTrait<'a> for ArrayEntity<'a> {
   }
 
   fn get_to_jsx_child(&'a self, _analyzer: &Analyzer<'a>) -> Entity<'a> {
-    self
+    self.into()
   }
 
   fn test_typeof(&self) -> TypeofResult {