feat: rework pure annotation

src/analyzer.rs

@@ -30,7 +30,7 @@ pub struct Analyzer<'a> {
   pub semantic: Semantic<'a>,
   pub span_stack: Vec<Span>,
   pub data: ExtraData<'a>,
-  pub referred_deps: ReferredDeps,
+  pub referred_deps: &'a mut ReferredDeps,
   pub conditional_data: ConditionalDataMap<'a>,
   pub loop_data: LoopDataMap<'a>,
   pub named_exports: Vec<SymbolId>,
@@ -39,7 +39,7 @@ pub struct Analyzer<'a> {
   pub pending_labels: Vec<LabelEntity<'a>>,
   pub pending_deps: FxHashSet<ExhaustiveCallback<'a>>,
   pub builtins: Builtins<'a>,
-  pub entity_op: EntityOpHost<'a>,
+  pub entity_op: &'a EntityOpHost<'a>,
 
   pub debug: usize,
 }
@@ -59,7 +59,7 @@ impl<'a> Analyzer<'a> {
       semantic,
       span_stack: vec![],
       data: Default::default(),
-      referred_deps: Default::default(),
+      referred_deps: allocator.alloc(ReferredDeps::default()),
       conditional_data: Default::default(),
       loop_data: Default::default(),
       named_exports: Vec::new(),
@@ -68,7 +68,7 @@ impl<'a> Analyzer<'a> {
       pending_labels: Vec::new(),
       pending_deps: Default::default(),
       builtins: Builtins::new(config, factory),
-      entity_op: EntityOpHost::new(allocator),
+      entity_op: allocator.alloc(EntityOpHost::new(allocator)),
       debug: 0,
     }
   }

src/builtins/globals/object_constructor.rs

@@ -66,7 +66,7 @@ impl<'a> Builtins<'a> {
       let array = analyzer.new_empty_array();
 
       for (_, key, value) in properties {
-        if key.test_typeof().contains(TypeofResult::String) {
+        if key.test_typeof(analyzer).contains(TypeofResult::String) {
           array.init_rest(analyzer.factory.computed(key.get_to_string(analyzer), value));
         }
       }

src/builtins/prototypes/function.rs

@@ -15,7 +15,7 @@ pub fn create_function_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'
         let cf_scope = analyzer.scope_context.cf.current_id();
         // This can be any value
         let arguments_object_id = SymbolId::from_usize(0);
-        match arg.test_is_undefined() {
+        match arg.test_is_undefined(analyzer) {
           Some(true) => analyzer.factory.entity(ArrayEntity::new(cf_scope, arguments_object_id)),
           Some(false) => arg,
           None => analyzer.factory.union((

src/builtins/prototypes/mod.rs

@@ -68,7 +68,7 @@ impl<'a> Prototype<'a> {
 
   pub fn get_property(
     &self,
-    analyzer: &Analyzer<'a>,
+    analyzer: &mut Analyzer<'a>,
     rc: Entity<'a>,
     key: Entity<'a>,
     dep: Consumable<'a>,

src/builtins/react/class_names.rs

@@ -14,12 +14,12 @@ pub fn create_class_names_namespace<'a>(
     let mut deps_1 = vec![];
     let mut deps_2 = vec![iterate_dep];
     for class_name in class_names {
-      if TypeofResult::Object.contains(class_name.test_typeof()) {
+      if TypeofResult::Object.contains(class_name.test_typeof(analyzer)) {
         // This may be an array. However, this makes no difference in this logic.
         let (properties, enumerate_dep) = class_name.enumerate_properties(analyzer, dep.cloned());
         deps_2.push(enumerate_dep);
         for (_, key, value) in properties {
-          if value.test_truthy() != Some(false) {
+          if value.test_truthy(analyzer) != Some(false) {
             deps_1.push(key);
             deps_1.push(value);
           }

src/builtins/react/create_element.rs

@@ -7,7 +7,7 @@ pub fn create_react_create_element_impl<'a>(factory: &'a EntityFactory<'a>) -> E
   factory.implemented_builtin_fn("React::createElement", |analyzer, dep, _this, args| {
     let (args, children, _) = args.destruct_as_array(analyzer, dep, 2);
     let [tag, props] = args[..] else { unreachable!() };
-    let props = match props.test_nullish() {
+    let props = match props.test_nullish(analyzer) {
       Some(true) => {
         analyzer.factory.entity(analyzer.new_empty_object(&analyzer.builtins.prototypes.object))
       }
@@ -20,7 +20,7 @@ pub fn create_react_create_element_impl<'a>(factory: &'a EntityFactory<'a>) -> E
 
     // Special prop: ref
     let r#ref = props.get_property(analyzer, box_consumable(()), analyzer.factory.string("ref"));
-    if r#ref.test_nullish() != Some(true) {
+    if r#ref.test_nullish(analyzer) != Some(true) {
       // TODO: currently we haven't implemented useRef, so we just consider it as a callback
       analyzer.exec_consumed_fn("React_ref", move |analyzer| {
         r#ref.call(
@@ -34,7 +34,7 @@ pub fn create_react_create_element_impl<'a>(factory: &'a EntityFactory<'a>) -> E
 
     // Special prop: key
     let key = props.get_property(analyzer, box_consumable(()), analyzer.factory.string("key"));
-    if r#ref.test_nullish() != Some(true) {
+    if r#ref.test_nullish(analyzer) != Some(true) {
       analyzer.consume(key);
     }
 

src/builtins/react/jsxs.rs

@@ -7,7 +7,8 @@ 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).0;
     let [tag, props, key] = args[..] else { unreachable!() };
-    analyzer.consume(props.get_destructable(box_consumable(())));
+    let destructable_dep = props.get_destructable(analyzer, box_consumable(()));
+    analyzer.consume(destructable_dep);
     props.set_property(analyzer, box_consumable(()), analyzer.factory.string("key"), key);
     analyzer.factory.react_element(tag, props)
   })

src/entity/arguments.rs

@@ -127,43 +127,48 @@ impl<'a> EntityTrait<'a> for ArgumentsEntity<'a> {
     (elements, rest.map(|val| analyzer.factory.union(val)), dep)
   }
 
-  fn get_destructable(&self, _rc: Entity<'a>, _dep: Consumable<'a>) -> Consumable<'a> {
+  fn get_destructable(
+    &self,
+    _rc: Entity<'a>,
+    _analyzer: &mut Analyzer<'a>,
+    _dep: Consumable<'a>,
+  ) -> Consumable<'a> {
     unreachable!()
   }
 
-  fn get_typeof(&self, _rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_typeof(&self, _rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
 
-  fn get_to_string(&self, _rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_string(&self, _rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
 
-  fn get_to_numeric(&self, _rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_numeric(&self, _rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
 
-  fn get_to_boolean(&self, _rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_boolean(&self, _rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
 
-  fn get_to_property_key(&self, _rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_property_key(&self, _rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
 
-  fn get_to_jsx_child(&self, _rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_jsx_child(&self, _rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     unreachable!()
   }
 
-  fn test_typeof(&self) -> TypeofResult {
+  fn test_typeof(&self, _analyzer: &mut Analyzer<'a>) -> TypeofResult {
     unreachable!()
   }
 
-  fn test_truthy(&self) -> Option<bool> {
+  fn test_truthy(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     unreachable!()
   }
 
-  fn test_nullish(&self) -> Option<bool> {
+  fn test_nullish(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     unreachable!()
   }
 }

src/entity/array.rs

@@ -347,49 +347,54 @@ impl<'a> EntityTrait<'a> for ArrayEntity<'a> {
     )
   }
 
-  fn get_destructable(&self, _rc: Entity<'a>, dep: Consumable<'a>) -> Consumable<'a> {
+  fn get_destructable(
+    &self,
+    _rc: Entity<'a>,
+    analyzer: &mut Analyzer<'a>,
+    dep: Consumable<'a>,
+  ) -> Consumable<'a> {
     dep
   }
 
-  fn get_typeof(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_typeof(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("object")
   }
 
-  fn get_to_string(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_string(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     if self.consumed.get() {
       return consumed_object::get_to_string(analyzer);
     }
     analyzer.factory.computed_unknown_string(rc)
   }
 
-  fn get_to_numeric(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_numeric(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     if self.consumed.get() {
       return consumed_object::get_to_numeric(analyzer);
     }
     analyzer.factory.computed_unknown(rc)
   }
 
-  fn get_to_boolean(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_boolean(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.boolean(true)
   }
 
-  fn get_to_property_key(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_property_key(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     self.get_to_string(rc, analyzer)
   }
 
-  fn get_to_jsx_child(&self, rc: Entity<'a>, _analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_jsx_child(&self, rc: Entity<'a>, _analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     rc
   }
 
-  fn test_typeof(&self) -> TypeofResult {
+  fn test_typeof(&self, _analyzer: &mut Analyzer<'a>) -> TypeofResult {
     TypeofResult::Object
   }
 
-  fn test_truthy(&self) -> Option<bool> {
+  fn test_truthy(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     Some(true)
   }
 
-  fn test_nullish(&self) -> Option<bool> {
+  fn test_nullish(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     Some(false)
   }
 }

src/entity/builtin_fn.rs

@@ -136,44 +136,49 @@ impl<'a, T: BuiltinFnEntity<'a>> EntityTrait<'a> for T {
     consumed_object::iterate(analyzer, dep)
   }
 
-  fn get_destructable(&self, rc: Entity<'a>, dep: Consumable<'a>) -> Consumable<'a> {
+  fn get_destructable(
+    &self,
+    rc: Entity<'a>,
+    _analyzer: &mut Analyzer<'a>,
+    dep: Consumable<'a>,
+  ) -> Consumable<'a> {
     box_consumable((rc, dep))
   }
 
-  fn get_typeof(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_typeof(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("function")
   }
 
-  fn get_to_string(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_string(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.computed_unknown_string(rc)
   }
 
-  fn get_to_numeric(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_numeric(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.nan
   }
 
-  fn get_to_boolean(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_boolean(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.boolean(true)
   }
 
-  fn get_to_property_key(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_property_key(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     self.get_to_string(rc, analyzer)
   }
 
-  fn get_to_jsx_child(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_jsx_child(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     // TODO: analyzer.thrown_builtin_error("Functions are not valid JSX children");
     analyzer.factory.string("")
   }
 
-  fn test_typeof(&self) -> TypeofResult {
+  fn test_typeof(&self, _analyzer: &mut Analyzer<'a>) -> TypeofResult {
     TypeofResult::Function
   }
 
-  fn test_truthy(&self) -> Option<bool> {
+  fn test_truthy(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     Some(true)
   }
 
-  fn test_nullish(&self) -> Option<bool> {
+  fn test_nullish(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     Some(false)
   }
 }

src/entity/class.rs

@@ -44,11 +44,9 @@ impl<'a> EntityTrait<'a> for ClassEntity<'a> {
     if self.consumed.get() {
       return consumed_object::get_property(rc, analyzer, dep, key);
     }
-    if analyzer.entity_op.strict_eq(
-      analyzer,
-      key.get_to_property_key(analyzer),
-      analyzer.factory.string("prototype"),
-    ) != Some(false)
+    let key = key.get_to_property_key(analyzer);
+    if analyzer.entity_op.strict_eq(analyzer, key, analyzer.factory.string("prototype"))
+      != Some(false)
     {
       self.consume(analyzer);
       return consumed_object::get_property(rc, analyzer, dep, key);
@@ -127,37 +125,42 @@ impl<'a> EntityTrait<'a> for ClassEntity<'a> {
     consumed_object::iterate(analyzer, dep)
   }
 
-  fn get_destructable(&self, rc: Entity<'a>, dep: Consumable<'a>) -> Consumable<'a> {
+  fn get_destructable(
+    &self,
+    rc: Entity<'a>,
+    _analyzer: &mut Analyzer<'a>,
+    dep: Consumable<'a>,
+  ) -> Consumable<'a> {
     box_consumable((rc, dep))
   }
 
-  fn get_typeof(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_typeof(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.string("function")
   }
 
-  fn get_to_string(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_string(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     if self.consumed.get() {
       return consumed_object::get_to_string(analyzer);
     }
     analyzer.factory.computed_unknown_string(rc)
   }
 
-  fn get_to_numeric(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_numeric(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     if self.consumed.get() {
       return consumed_object::get_to_numeric(analyzer);
     }
     analyzer.factory.nan
   }
 
-  fn get_to_boolean(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_boolean(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     analyzer.factory.boolean(true)
   }
 
-  fn get_to_property_key(&self, rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_property_key(&self, rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     self.get_to_string(rc, analyzer)
   }
 
-  fn get_to_jsx_child(&self, _rc: Entity<'a>, analyzer: &Analyzer<'a>) -> Entity<'a> {
+  fn get_to_jsx_child(&self, _rc: Entity<'a>, analyzer: &mut Analyzer<'a>) -> Entity<'a> {
     if self.consumed.get() {
       analyzer.factory.immutable_unknown
     } else {
@@ -166,15 +169,15 @@ impl<'a> EntityTrait<'a> for ClassEntity<'a> {
     }
   }
 
-  fn test_typeof(&self) -> TypeofResult {
+  fn test_typeof(&self, _analyzer: &mut Analyzer<'a>) -> TypeofResult {
     TypeofResult::Function
   }
 
-  fn test_truthy(&self) -> Option<bool> {
+  fn test_truthy(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     Some(true)
   }
 
-  fn test_nullish(&self) -> Option<bool> {
+  fn test_nullish(&self, _analyzer: &mut Analyzer<'a>) -> Option<bool> {
     Some(false)
   }
 }