Merge branch 'main' of https://github.com/KermanX/tree-shaker

Author: kermanx

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

@@ -1,6 +1,6 @@
 use crate::{
   builtins::{constants::OBJECT_CONSTRUCTOR_OBJECT_ID, Builtins},
-  entity::{Entity, LiteralEntity, ObjectPropertyValue, TypeofResult},
+  entity::{Entity, LiteralEntity, ObjectPropertyValue, ObjectPrototype, TypeofResult},
   init_namespace,
 };
 use std::borrow::BorrowMut;
@@ -9,8 +9,11 @@ impl<'a> Builtins<'a> {
   pub fn init_object_constructor(&mut self) {
     let factory = self.factory;
 
-    let object =
-      factory.builtin_object(OBJECT_CONSTRUCTOR_OBJECT_ID, &self.prototypes.function, false);
+    let object = factory.builtin_object(
+      OBJECT_CONSTRUCTOR_OBJECT_ID,
+      ObjectPrototype::Builtin(&self.prototypes.function),
+      false,
+    );
     object.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
     init_namespace!(object, {

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

@@ -1,6 +1,6 @@
 use crate::{
   builtins::{constants::SYMBOL_CONSTRUCTOR_OBJECT_ID, Builtins},
-  entity::ObjectPropertyValue,
+  entity::{ObjectPropertyValue, ObjectPrototype},
   init_namespace,
 };
 use std::borrow::BorrowMut;
@@ -9,8 +9,11 @@ impl<'a> Builtins<'a> {
   pub fn init_symbol_constructor(&mut self) {
     let factory = self.factory;
 
-    let object =
-      factory.builtin_object(SYMBOL_CONSTRUCTOR_OBJECT_ID, &self.prototypes.function, false);
+    let object = factory.builtin_object(
+      SYMBOL_CONSTRUCTOR_OBJECT_ID,
+      ObjectPrototype::Builtin(&self.prototypes.function),
+      false,
+    );
     object.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
     init_namespace!(object, {

crates/tree_shaker/src/builtins/import_meta.rs

@@ -1,12 +1,13 @@
 use super::{constants::IMPORT_META_OBJECT_ID, prototypes::BuiltinPrototypes, Builtins};
-use crate::entity::{Entity, EntityFactory, ObjectProperty, ObjectPropertyValue};
+use crate::entity::{Entity, EntityFactory, ObjectProperty, ObjectPropertyValue, ObjectPrototype};
 
 impl<'a> Builtins<'a> {
   pub fn create_import_meta(
     factory: &'a EntityFactory<'a>,
-    prototypes: &'a BuiltinPrototypes<'a>,
+    _prototypes: &'a BuiltinPrototypes<'a>,
   ) -> Entity<'a> {
-    let object = factory.builtin_object(IMPORT_META_OBJECT_ID, &prototypes.null, true);
+    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),

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

@@ -1,7 +1,7 @@
 use crate::{
   analyzer::Analyzer,
   consumable::{Consumable, ConsumableTrait},
-  entity::{Entity, EntityFactory},
+  entity::{Entity, EntityFactory, ObjectPrototype},
   init_object,
 };
 use oxc::semantic::SymbolId;
@@ -42,7 +42,8 @@ pub fn create_react_create_context_impl<'a>(factory: &'a EntityFactory<'a>) -> E
     let default_value =
       args.destruct_as_array(analyzer, analyzer.factory.empty_consumable, 1, false).0[0];
 
-    let context = analyzer.new_empty_object(&analyzer.builtins.prototypes.object, None);
+    let context = analyzer
+      .new_empty_object(ObjectPrototype::Builtin(&analyzer.builtins.prototypes.object), None);
 
     let context_id = analyzer.builtins.react_data.contexts.push(ReactContextData {
       object_id: context.object_id,

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

@@ -1,15 +1,18 @@
-use crate::entity::{Entity, EntityFactory};
+use crate::entity::{Entity, EntityFactory, ObjectPrototype};
 
 pub fn create_react_create_element_impl<'a>(factory: &'a EntityFactory<'a>) -> Entity<'a> {
   factory.implemented_builtin_fn("React::createElement", |analyzer, dep, _this, args| {
     let (args, children, _) = args.destruct_as_array(analyzer, dep, 2, true);
     let [tag, props] = args[..] else { unreachable!() };
     let props = match props.test_nullish() {
-      Some(true) => analyzer.new_empty_object(&analyzer.builtins.prototypes.object, None),
+      Some(true) => analyzer
+        .new_empty_object(ObjectPrototype::Builtin(&analyzer.builtins.prototypes.object), None),
       Some(false) => props,
       None => analyzer.factory.union((
         props,
-        analyzer.new_empty_object(&analyzer.builtins.prototypes.object, None) as Entity<'a>,
+        analyzer
+          .new_empty_object(ObjectPrototype::Builtin(&analyzer.builtins.prototypes.object), None)
+          as Entity<'a>,
       )),
     };
 

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

@@ -13,7 +13,7 @@ use super::{
   prototypes::BuiltinPrototypes,
 };
 use crate::{
-  entity::{Entity, EntityFactory, ObjectPropertyValue},
+  entity::{Entity, EntityFactory, ObjectPropertyValue, ObjectPrototype},
   init_namespace,
 };
 pub use class_names::create_class_names_namespace;
@@ -36,9 +36,10 @@ pub struct AnalyzerDataForReact<'a> {
 
 pub fn create_react_namespace<'a>(
   factory: &'a EntityFactory<'a>,
-  prototypes: &'a BuiltinPrototypes<'a>,
+  _prototypes: &'a BuiltinPrototypes<'a>,
 ) -> Entity<'a> {
-  let namespace = factory.builtin_object(REACT_NAMESPACE_OBJECT_ID, &prototypes.null, false);
+  let namespace =
+    factory.builtin_object(REACT_NAMESPACE_OBJECT_ID, ObjectPrototype::ImplicitOrNull, false);
   namespace.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
   init_namespace!(namespace, {
@@ -55,10 +56,13 @@ pub fn create_react_namespace<'a>(
 
 pub fn create_react_jsx_runtime_namespace<'a>(
   factory: &'a EntityFactory<'a>,
-  prototypes: &'a BuiltinPrototypes<'a>,
+  _prototypes: &'a BuiltinPrototypes<'a>,
 ) -> Entity<'a> {
-  let object =
-    factory.builtin_object(REACT_JSX_RUNTIME_NAMESPACE_OBJECT_ID, &prototypes.null, false);
+  let object = factory.builtin_object(
+    REACT_JSX_RUNTIME_NAMESPACE_OBJECT_ID,
+    ObjectPrototype::ImplicitOrNull,
+    false,
+  );
   object.init_rest(ObjectPropertyValue::Field(factory.immutable_unknown, true));
 
   init_namespace!(object, {

crates/tree_shaker/src/entity/factory.rs

@@ -1,5 +1,4 @@
 use crate::{
-  builtins::Prototype,
   consumable::{Consumable, ConsumableTrait, LazyConsumable, OnceConsumable},
   mangling::{AlwaysMangableDep, MangleAtom, MangleConstraint, ManglingDep},
   module::ModuleId,
@@ -18,8 +17,8 @@ use super::{
   react_element::ReactElementEntity,
   union::UnionEntity,
   utils::UnionLike,
-  ClassEntity, Entity, LiteralEntity, ObjectEntity, PrimitiveEntity, PureBuiltinFnEntity,
-  UnknownEntity,
+  ClassEntity, Entity, LiteralEntity, ObjectEntity, ObjectPrototype, PrimitiveEntity,
+  PureBuiltinFnEntity, UnknownEntity,
 };
 use oxc::semantic::SymbolId;
 use oxc::{allocator::Allocator, ast::ast::Class};
@@ -150,7 +149,7 @@ impl<'a> EntityFactory<'a> {
   pub fn builtin_object(
     &self,
     object_id: SymbolId,
-    prototype: &'a Prototype<'a>,
+    prototype: ObjectPrototype<'a>,
     consumable: bool,
   ) -> &'a mut ObjectEntity<'a> {
     self.alloc(ObjectEntity {

crates/tree_shaker/src/entity/mod.rs

@@ -25,7 +25,7 @@ pub use builtin_fn::PureBuiltinFnEntity;
 pub use class::ClassEntity;
 pub use factory::EntityFactory;
 pub use literal::LiteralEntity;
-pub use object::{ObjectEntity, ObjectProperty, ObjectPropertyValue};
+pub use object::{ObjectEntity, ObjectProperty, ObjectPropertyValue, ObjectPrototype};
 pub use primitive::PrimitiveEntity;
 use rustc_hash::FxHashSet;
 use std::{cmp::Ordering, fmt::Debug};

crates/tree_shaker/src/entity/never.rs

@@ -96,7 +96,7 @@ impl<'a> EntityTrait<'a> for NeverEntity {
     &'a self,
     _analyzer: &Analyzer<'a>,
   ) -> Option<rustc_hash::FxHashSet<super::LiteralEntity<'a>>> {
-    None
+    Some(rustc_hash::FxHashSet::default())
   }
   fn get_literal(&'a self, _analyzer: &Analyzer<'a>) -> Option<super::LiteralEntity<'a>> {
     None

crates/tree_shaker/src/entity/object/enumerate.rs

@@ -1,4 +1,4 @@
-use super::ObjectEntity;
+use super::{get::GetPropertyContext, ObjectEntity};
 use crate::{
   analyzer::Analyzer,
   consumable::Consumable,
@@ -21,25 +21,31 @@ impl<'a> ObjectEntity<'a> {
     analyzer.push_cf_scope_with_deps(CfScopeKind::Dependent, vec![dep], None);
 
     let mut result = vec![];
-    let mut non_existent = vec![];
+    let mut context = GetPropertyContext {
+      key: analyzer.factory.never,
+      values: vec![],
+      getters: vec![],
+      extra_deps: vec![],
+    };
 
     {
-      let mut values = vec![];
-      let mut getters = vec![];
-
       {
         let mut unknown_keyed = self.unknown_keyed.borrow_mut();
-        unknown_keyed.get(analyzer, &mut values, &mut getters, &mut non_existent);
+        unknown_keyed.get(analyzer, &mut context, None);
         if let Some(rest) = &mut *self.rest.borrow_mut() {
-          rest.get(analyzer, &mut values, &mut getters, &mut non_existent);
+          rest.get(analyzer, &mut context, None);
         }
       }
 
-      for getter in getters {
-        values.push(getter.call_as_getter(analyzer, analyzer.factory.empty_consumable, self));
+      for getter in context.getters.drain(..) {
+        context.values.push(getter.call_as_getter(
+          analyzer,
+          analyzer.factory.empty_consumable,
+          self,
+        ));
       }
 
-      if let Some(value) = analyzer.factory.try_union(values) {
+      if let Some(value) = analyzer.factory.try_union(mem::take(&mut context.values)) {
         result.push((false, analyzer.factory.unknown_primitive, value));
       }
     }
@@ -64,22 +70,24 @@ impl<'a> ObjectEntity<'a> {
           analyzer.factory.string(key)
         };
 
-        let mut values = vec![];
-        let mut getters = vec![];
-        property.get(analyzer, &mut values, &mut getters, &mut non_existent);
+        property.get(analyzer, &mut context, None);
         mem::drop(string_keyed);
-        for getter in getters {
-          values.push(getter.call_as_getter(analyzer, analyzer.factory.empty_consumable, self));
+        for getter in context.getters.drain(..) {
+          context.values.push(getter.call_as_getter(
+            analyzer,
+            analyzer.factory.empty_consumable,
+            self,
+          ));
         }
 
-        if let Some(value) = analyzer.factory.try_union(values) {
+        if let Some(value) = analyzer.factory.try_union(mem::take(&mut context.values)) {
           result.push((definite, key_entity, value));
         }
       }
     }
 
     analyzer.pop_cf_scope();
 
-    (result, analyzer.consumable((dep, non_existent)))
+    (result, analyzer.consumable((dep, context.extra_deps)))
   }
 }