fix!!!!!!!!!!!!

Author: kermanx

crates/tree_shaker/src/analyzer.rs

@@ -10,7 +10,7 @@ use crate::{
     Scoping,
     conditional::ConditionalDataMap,
     exhaustive::{ExhaustiveCallback, ExhaustiveDepId},
-    r#loop::LoopDataMap,
+    // r#loop::LoopDataMap,
   },
   utils::ExtraData,
   vfs::Vfs,
@@ -23,7 +23,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use std::{collections::BTreeSet, mem};
 
 pub struct Analyzer<'a> {
-  pub vfs: &'a dyn Vfs,
+  pub vfs: Box<dyn Vfs>,
   pub config: &'a TreeShakeConfig,
   pub allocator: &'a Allocator,
   pub factory: &'a EntityFactory<'a>,
@@ -39,21 +39,17 @@ pub struct Analyzer<'a> {
   pub exhaustive_callbacks: FxHashMap<ExhaustiveDepId, FxHashSet<ExhaustiveCallback<'a>>>,
   pub referred_deps: ReferredDeps,
   pub conditional_data: ConditionalDataMap<'a>,
-  pub loop_data: LoopDataMap<'a>,
+  // pub loop_data: LoopDataMap<'a>,
   pub folder: ConstantFolder<'a>,
   pub mangler: Mangler<'a>,
   pub pending_deps: FxHashSet<ExhaustiveCallback<'a>>,
   pub diagnostics: BTreeSet<String>,
 }
 
 impl<'a> Analyzer<'a> {
-  pub fn new_in(
-    vfs: &'a dyn Vfs,
-    config: &'a TreeShakeConfig,
-    allocator: &'a Allocator,
-  ) -> &'a mut Self {
+  pub fn new_in(vfs: Box<dyn Vfs>, config: &'a TreeShakeConfig, allocator: &'a Allocator) -> Self {
     let factory = &*allocator.alloc(EntityFactory::new(allocator, config));
-    allocator.alloc(Analyzer {
+    Analyzer {
       vfs,
       config,
       allocator,
@@ -70,12 +66,12 @@ impl<'a> Analyzer<'a> {
       exhaustive_callbacks: Default::default(),
       referred_deps: Default::default(),
       conditional_data: Default::default(),
-      loop_data: Default::default(),
+      // loop_data: Default::default(),
       folder: Default::default(),
       mangler: Mangler::new(config.mangling.is_some(), allocator),
       pending_deps: Default::default(),
       diagnostics: Default::default(),
-    })
+    }
   }
 
   pub fn finalize(&mut self) {
@@ -94,7 +90,7 @@ impl<'a> Analyzer<'a> {
       dirty |= self.consume_top_level_uncaught();
       dirty |= self.call_exhaustive_callbacks();
       dirty |= self.post_analyze_handle_conditional();
-      dirty |= self.post_analyze_handle_loops();
+      // dirty |= self.post_analyze_handle_loops();
       dirty |= self.post_analyze_handle_folding();
       if !dirty {
         break;
@@ -108,11 +104,12 @@ impl<'a> Analyzer<'a> {
   }
 
   fn consume_top_level_uncaught(&mut self) -> bool {
+    let factory = self.factory;
     let thrown_values = &mut self.call_scope_mut().try_scopes.last_mut().unwrap().thrown_values;
     if thrown_values.is_empty() {
       false
     } else {
-      let values = mem::take(thrown_values);
+      let values = mem::replace(thrown_values, factory.vec());
       self.consume(values);
       true
     }

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

@@ -14,9 +14,9 @@ impl<'a> Builtins<'a> {
       ObjectPrototype::Builtin(&self.prototypes.function),
       false,
     );
-    object.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
+    object.init_rest(factory, ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
-    init_namespace!(object, {
+    init_namespace!(object, factory, {
       "prototype" => factory.immutable_unknown,
       "assign" => self.create_object_assign_impl(),
       "keys" => self.create_object_keys_impl(),

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

@@ -14,9 +14,9 @@ impl Builtins<'_> {
       ObjectPrototype::Builtin(&self.prototypes.function),
       false,
     );
-    object.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
+    object.init_rest(factory, ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
-    init_namespace!(object, {
+    init_namespace!(object, factory, {
       "prototype" => factory.immutable_unknown,
       // "asyncIterator" => factory.string("__#asyncIterator__"),
       // "hasInstance" => factory.string("__#hasInstance__"),

crates/tree_shaker/src/builtins/import_meta.rs

@@ -1,5 +1,8 @@
 use super::{Builtins, constants::IMPORT_META_OBJECT_ID, prototypes::BuiltinPrototypes};
-use crate::entity::{Entity, EntityFactory, ObjectProperty, ObjectPropertyValue, ObjectPrototype};
+use crate::{
+  consumable::ConsumableCollector,
+  entity::{Entity, EntityFactory, ObjectProperty, ObjectPropertyValue, ObjectPrototype},
+};
 
 impl<'a> Builtins<'a> {
   pub fn create_import_meta(
@@ -8,24 +11,27 @@ impl<'a> Builtins<'a> {
   ) -> Entity<'a> {
     let object =
       factory.builtin_object(IMPORT_META_OBJECT_ID, ObjectPrototype::ImplicitOrNull, true);
-    object.init_rest(ObjectPropertyValue::Property(
-      Some(factory.immutable_unknown),
-      Some(factory.immutable_unknown),
-    ));
+    object.init_rest(
+      factory,
+      ObjectPropertyValue::Property(
+        Some(factory.immutable_unknown),
+        Some(factory.immutable_unknown),
+      ),
+    );
 
     // import.meta.url
     object.string_keyed.borrow_mut().insert(
       "url",
       ObjectProperty {
         definite: true,
         enumerable: true,
-        possible_values: vec![ObjectPropertyValue::Property(
+        possible_values: factory.vec1(ObjectPropertyValue::Property(
           Some(factory.implemented_builtin_fn("import.meta.url", |analyzer, _, _, _| {
             analyzer.factory.unknown_string
           })),
           None,
-        )],
-        non_existent: Default::default(),
+        )),
+        non_existent: ConsumableCollector::new(factory.vec()),
         key: None,
         mangling: None,
       },

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

@@ -18,16 +18,14 @@ use crate::{
   consumable::Consumable,
   entity::{Entity, EntityFactory, LiteralEntity},
 };
-use oxc::semantic::SymbolId;
-use rustc_hash::FxHashMap;
+use oxc::{allocator, semantic::SymbolId};
 
 use super::Builtins;
 
-#[derive(Default)]
 pub struct BuiltinPrototype<'a> {
   name: &'static str,
-  string_keyed: FxHashMap<&'static str, Entity<'a>>,
-  symbol_keyed: FxHashMap<SymbolId, Entity<'a>>,
+  string_keyed: allocator::HashMap<'a, &'static str, Entity<'a>>,
+  symbol_keyed: allocator::HashMap<'a, SymbolId, Entity<'a>>,
 }
 
 impl fmt::Debug for BuiltinPrototype<'_> {
@@ -37,6 +35,14 @@ impl fmt::Debug for BuiltinPrototype<'_> {
 }
 
 impl<'a> BuiltinPrototype<'a> {
+  pub fn new_in(factory: &EntityFactory<'a>) -> Self {
+    Self {
+      name: "",
+      string_keyed: allocator::HashMap::new_in(factory.allocator),
+      symbol_keyed: allocator::HashMap::new_in(factory.allocator),
+    }
+  }
+
   pub fn with_name(mut self, name: &'static str) -> Self {
     self.name = name;
     self
@@ -75,7 +81,7 @@ impl<'a> BuiltinPrototype<'a> {
   ) -> Entity<'a> {
     let dep = (dep, target, key);
     if let Some(key_literals) = key.get_to_literals(analyzer) {
-      let mut values = vec![];
+      let mut values = analyzer.factory.vec();
       for key_literal in key_literals {
         if let Some(property) = self.get_literal_keyed(key_literal) {
           values.push(property);

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

@@ -1,6 +1,6 @@
 use super::BuiltinPrototype;
 use crate::entity::EntityFactory;
 
-pub fn create_null_prototype<'a>(_factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
-  BuiltinPrototype::default().with_name("null")
+pub fn create_null_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
+  BuiltinPrototype::new_in(factory).with_name("null")
 }

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

@@ -10,8 +10,8 @@ pub fn create_class_names_namespace<'a>(
   factory.implemented_builtin_fn("classnames::default", |analyzer, dep, _this, args| {
     let (class_names, rest, iterate_dep) = args.iterate(analyzer, dep);
 
-    let mut deps_1 = vec![];
-    let mut deps_2 = vec![iterate_dep];
+    let mut deps_1 = factory.vec();
+    let mut deps_2 = factory.vec1(iterate_dep);
     for class_name in class_names {
       if TypeofResult::Object.contains(class_name.test_typeof()) {
         // This may be an array. However, this makes no difference in this logic.

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

@@ -53,7 +53,7 @@ pub fn create_react_create_context_impl<'a>(factory: &'a EntityFactory<'a>) -> E
       dep,
     });
 
-    init_object!(context, {
+    init_object!(context, factory, {
       "__#internal__consumed_hook" => analyzer.factory.computed_unknown(context_id),
       "__#internal__context_id" => analyzer.serialize_internal_id(context_id),
       "Provider" => create_react_context_provider_impl(analyzer, context_id),
@@ -69,11 +69,13 @@ impl<'a> ConsumableTrait<'a> for ContextId {
     let data = &mut analyzer.builtins.react_data.contexts[*self];
     data.consumed = true;
     let default_value = data.default_value;
-    let stack = mem::take(&mut data.stack);
     let dep = data.dep;
+    let stack = mem::take(&mut data.stack);
     analyzer.consume(default_value);
-    analyzer.consume(stack);
     analyzer.consume(dep);
+    for value in stack {
+      analyzer.consume(value);
+    }
   }
 }
 

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

@@ -9,7 +9,7 @@ use oxc::span::Span;
 use rustc_hash::FxHashMap;
 use std::{cell::RefCell, rc::Rc, vec};
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ReactDependenciesData<'a> {
   pub collectors: Vec<ConsumableCollector<'a, Entity<'a>>>,
   pub rest_collector: ConsumableCollector<'a, Entity<'a>>,
@@ -33,11 +33,24 @@ pub fn check_dependencies<'a>(
   let (elements, rest, iterate_dep) = current.iterate(analyzer, dep);
 
   let span = (analyzer.current_module(), analyzer.current_span());
-  let data = analyzer.builtins.react_data.dependencies.entry(span).or_default().clone();
+  let data = analyzer
+    .builtins
+    .react_data
+    .dependencies
+    .entry(span)
+    .or_insert_with(|| {
+      Rc::new(RefCell::new(ReactDependenciesData {
+        collectors: vec![],
+        rest_collector: ConsumableCollector::new(factory.vec()),
+        extra_collector: ConsumableCollector::new(factory.vec()),
+        previous: None,
+      }))
+    })
+    .clone();
   let mut data = data.borrow_mut();
 
   if data.collectors.len() <= elements.len() {
-    data.collectors.resize_with(elements.len(), ConsumableCollector::default);
+    data.collectors.resize_with(elements.len(), || ConsumableCollector::new(factory.vec()));
   }
   for (index, element) in elements.iter().enumerate() {
     data.collectors[index].push(*element);
@@ -83,7 +96,7 @@ pub fn check_dependencies<'a>(
         (false, extra_collector.collect(factory))
       }
     } else {
-      let mut deps = vec![];
+      let mut deps = analyzer.factory.vec();
       for index in &changed {
         deps.push(collectors[*index].collect(factory));
         if let Some(previous) = previous.get_mut(*index) {
@@ -106,7 +119,7 @@ pub fn check_dependencies<'a>(
   } else {
     require_rerun = true;
     for element in &elements {
-      collectors.push(ConsumableCollector::new(vec![*element]));
+      collectors.push(ConsumableCollector::new(analyzer.factory.vec1(*element)));
     }
     if let Some(rest) = rest {
       rest_collector.push(rest);

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

@@ -1,3 +1,5 @@
+use oxc::allocator;
+
 use crate::entity::{Entity, EntityFactory};
 
 pub fn create_react_forward_ref_impl<'a>(factory: &'a EntityFactory<'a>) -> Entity<'a> {
@@ -15,7 +17,10 @@ pub fn create_react_forward_ref_impl<'a>(factory: &'a EntityFactory<'a>) -> Enti
           analyzer,
           dep,
           this,
-          analyzer.factory.arguments(vec![(false, props), (false, r#ref)]),
+          analyzer.factory.arguments(allocator::Vec::from_array_in(
+            [(false, props), (false, r#ref)],
+            analyzer.allocator,
+          )),
         )
       },
     )

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

@@ -40,9 +40,9 @@ pub fn create_react_namespace<'a>(
 ) -> Entity<'a> {
   let namespace =
     factory.builtin_object(REACT_NAMESPACE_OBJECT_ID, ObjectPrototype::ImplicitOrNull, false);
-  namespace.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
+  namespace.init_rest(factory, ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
-  init_namespace!(namespace, {
+  init_namespace!(namespace, factory, {
     "forwardRef" => create_react_forward_ref_impl(factory),
     "memo" => create_react_memo_impl(factory),
     "createElement" => create_react_create_element_impl(factory),
@@ -63,9 +63,9 @@ pub fn create_react_jsx_runtime_namespace<'a>(
     ObjectPrototype::ImplicitOrNull,
     false,
   );
-  object.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
+  object.init_rest(factory, ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
-  init_namespace!(object, {
+  init_namespace!(object, factory, {
     "jsx" => create_react_jsx_impl(factory),
     "jsxs" => create_react_jsxs_impl(factory),
   });

crates/tree_shaker/src/builtins/utils.rs

@@ -1,16 +1,17 @@
 #[macro_export]
 macro_rules! init_namespace {
-  ($ns:expr, { $($k:expr => $v:expr,)* }) => {
+  ($ns:expr, $factory:expr, { $($k:expr => $v:expr,)* }) => {
     {
       use $crate::entity::{ObjectProperty, ObjectPropertyValue};
+      use $crate::consumable::ConsumableCollector;
       let mut string_keyed = $ns.string_keyed.borrow_mut();
       $(string_keyed.insert(
         $k,
         ObjectProperty {
           definite: true,
           enumerable: false,
-          possible_values: vec![ObjectPropertyValue::Field($v, true)],
-          non_existent: Default::default(),
+          possible_values:  $factory.vec1(ObjectPropertyValue::Field($v, true)),
+          non_existent: ConsumableCollector::new($factory.vec()),
           key: None,
           mangling: None,
         },
@@ -21,17 +22,18 @@ macro_rules! init_namespace {
 
 #[macro_export]
 macro_rules! init_object {
-  ($ns:expr, { $($k:expr => $v:expr,)* }) => {
+  ($ns:expr, $factory:expr, { $($k:expr => $v:expr,)* }) => {
     {
       use $crate::entity::{ObjectProperty, ObjectPropertyValue};
+      use $crate::consumable::ConsumableCollector;
       let mut string_keyed = $ns.string_keyed.borrow_mut();
       $(string_keyed.insert(
         $k,
         ObjectProperty {
           definite: true,
           enumerable: true,
-          possible_values: vec![ObjectPropertyValue::Field($v, false)],
-          non_existent: Default::default(),
+          possible_values: $factory.vec1(ObjectPropertyValue::Field($v, false)),
+          non_existent: ConsumableCollector::new($factory.vec()),
           key: None,
           mangling: None,
         },