fix

Author: kermanx

Diff for: crates/tree_shaker/src/consumable/mod.rs

@@ -19,6 +19,7 @@ pub struct Consumable<'a>(pub &'a (dyn ConsumableTrait<'a> + 'a));
 pub type ConsumableVec<'a> = Vec<Consumable<'a>>;
 
 impl<'a> Analyzer<'a> {
+  #[inline]
   pub fn consume(&mut self, dep: impl ConsumableTrait<'a> + 'a) {
     dep.consume(self);
   }

Diff for: crates/tree_shaker/src/entity/factory.rs

@@ -154,7 +154,6 @@ impl<'a> EntityFactory<'a> {
       consumable,
       consumed: Cell::new(false),
       consumed_as_prototype: Cell::new(false),
-      pending_clear: Cell::new(false),
       cf_scope: CfScopeId::new(0),
       object_id,
       string_keyed: Default::default(),

Diff for: crates/tree_shaker/src/entity/object/mod.rs

@@ -51,7 +51,6 @@ pub struct ObjectEntity<'a> {
   pub consumable: bool,
   pub consumed: Cell<bool>,
   pub consumed_as_prototype: Cell<bool>,
-  pub pending_clear: Cell<bool>,
   // deps: RefCell<ConsumableCollector<'a>>,
   /// Where the object is created
   pub cf_scope: CfScopeId,
@@ -80,13 +79,8 @@ impl<'a> EntityTrait<'a> for ObjectEntity<'a> {
 
     self.consume_as_prototype(analyzer);
 
-    // FIXME: Need a better way to do this
-    if let Ok(mut string_keyed) = self.string_keyed.try_borrow_mut() {
-      string_keyed.clear();
-      self.unknown_keyed.take();
-    } else {
-      self.pending_clear.set(true);
-    }
+    self.string_keyed.borrow_mut().clear();
+    self.unknown_keyed.take();
 
     analyzer.mark_object_consumed(self.cf_scope, self.object_id);
   }
@@ -257,15 +251,12 @@ impl<'a> ObjectEntity<'a> {
 
     self.prototype.get().consume(analyzer);
 
+    let mut suspended = vec![];
     for property in self.string_keyed.borrow().values() {
-      property.consume(analyzer);
-    }
-    self.unknown_keyed.borrow().consume(analyzer);
-
-    if self.pending_clear.replace(false) {
-      self.string_keyed.borrow_mut().clear();
-      self.unknown_keyed.take();
+      property.consume(analyzer, &mut suspended);
     }
+    self.unknown_keyed.borrow().consume(analyzer, &mut suspended);
+    analyzer.consume(suspended);
   }
 
   pub fn is_mangable(&self) -> bool {
@@ -312,7 +303,6 @@ impl<'a> Analyzer<'a> {
       consumable: true,
       consumed: Cell::new(false),
       consumed_as_prototype: Cell::new(false),
-      pending_clear: Cell::new(false),
       // deps: Default::default(),
       cf_scope: self.scoping.cf.current_id(),
       object_id: self.scoping.alloc_object_id(),

Diff for: crates/tree_shaker/src/entity/object/property.rs

@@ -172,21 +172,25 @@ impl<'a> ObjectProperty<'a> {
     self.non_existent.push(dep);
   }
 
-  pub fn consume(&self, analyzer: &mut Analyzer<'a>) {
+  pub fn consume(&self, analyzer: &mut Analyzer<'a>, suspended: &mut Vec<Entity<'a>>) {
     for &possible_value in &self.possible_values {
       match possible_value {
-        ObjectPropertyValue::Field(value, _) => analyzer.consume(value),
+        ObjectPropertyValue::Field(value, _) => suspended.push(value),
         ObjectPropertyValue::Property(getter, setter) => {
-          analyzer.consume(getter);
-          analyzer.consume(setter);
+          if let Some(getter) = getter {
+            suspended.push(getter);
+          }
+          if let Some(setter) = setter {
+            suspended.push(setter);
+          }
         }
       }
     }
 
     self.non_existent.consume_all(analyzer);
 
     if let Some(key) = self.key {
-      analyzer.consume(key);
+      suspended.push(key);
     }
   }
 }