feat: support tree shaking class members (#42)

Author: kermanx

README.md

@@ -121,6 +121,47 @@ export function main() {
 
 </td></tr></tbody></table>
 
+### Class Tree Shaking
+
+> One of the hardest but the coolest.
+
+<table><tbody><tr><td width="500px"> Input </td><td width="500px"> Output </td></tr><tr>
+<td valign="top">
+
+```js
+class A {
+  method(x) {
+    console.log("A", x);
+  }
+  static static_prop = unknown;
+}
+class B extends A {
+  method(x) {
+    console.log("B", x);
+  }
+  unused() {
+    console.log("unused");
+  }
+}
+new B().method(A.static_prop);
+```
+
+</td><td valign="top">
+
+```js
+class A {
+  static a = unknown;
+}
+class B extends A {
+  a(x) {
+    console.log("B", x);
+  }
+}
+new B().a(A.a);
+```
+
+</td></tr></tbody></table>
+
 ### JSX
 
 > `createElement` also works, if it is directly imported from `react`.
@@ -204,9 +245,16 @@ export function main() {
 
 ## Comparison
 
-- **Rollup**: Rollup tree-shakes the code in a multi-module context, while this project is focused on a single module. For some cases, this project can remove 10% more code than Rollup.
-- **Closure Compiler**: Closure Compiler can be considered as a tree shaker + minifier, while this project is only a tree shaker (for the minifier, we have `oxc_minifier`). Theoretically, we can shake more than Closure Compiler, but we cannot compare them directly because we don't have a equivalent minifier. Also, it's written in Java, which is hard to be integrated into the JS ecosystem.
-- **swc**: swc can also be considered as a tree shaker + minifier. TBH, currently swc is much faster and more complete. It is rule-based, which is a different approach from this project. It's also not compatible with the Oxc project, thus a new tree shaker is needed.
+- **Rollup**: Rollup tree-shakes the code in a multi-module context, and it has information about the side effects of the modules. This project does a more fine-grained tree-shaking, and it can be used as a post-processor for Rollup, and is expected to produce smaller code.
+- **Closure Compiler**/**swc**: they support both minification and dead code elimination, while this project is focused on tree-shaking (difference below). You can expect a size reduction when using tree-shaker on their output, and vice versa.
+
+### What's Tree Shaking?
+
+Here is a simple comparison:
+
+- Minification: Removing whitespace, renaming variables, syntax-level optimizations, etc.
+- Dead code elimination: Removing code that is never executed, by using a set of rules, for example, "`if(false) { ... }` can be removed".
+- Tree shaking: Removing code that is never executed, by simulating the runtime behavior of the code. For example, "`if (x) { ... }` can only be preserved if `...` is reachable and has side effects".
 
 ## Todo
 

crates/tree_shaker/src/builtins/mod.rs

@@ -11,8 +11,8 @@ use crate::{
   TreeShakeConfig,
 };
 use known_modules::KnownModule;
+pub use prototypes::BuiltinPrototype;
 use prototypes::BuiltinPrototypes;
-pub use prototypes::Prototype;
 use react::AnalyzerDataForReact;
 use rustc_hash::FxHashMap;
 

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_array_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_array_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Array", create_object_prototype(factory), {
     "at" => factory.immutable_unknown,
     "concat" => factory.immutable_unknown /*pure_fn_returns_array*/,

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

@@ -1,7 +1,7 @@
 use crate::entity::EntityFactory;
 
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 
-pub fn create_bigint_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_bigint_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   create_object_prototype(factory).with_name("BigInt")
 }

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_boolean_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_boolean_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Boolean", create_object_prototype(factory), {
     "valueOf" => factory.pure_fn_returns_boolean,
   })

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

@@ -1,12 +1,12 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{
   entity::{Entity, EntityFactory},
   init_prototype,
 };
 use oxc::semantic::SymbolId;
 use oxc_index::Idx;
 
-pub fn create_function_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_function_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Function", create_object_prototype(factory), {
     "apply" => factory.implemented_builtin_fn("Function::apply", |analyzer, dep, this, args| {
       let mut args = args.destruct_as_array(analyzer, dep, 2, false).0;

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

@@ -24,19 +24,19 @@ use rustc_hash::FxHashMap;
 use super::Builtins;
 
 #[derive(Default)]
-pub struct Prototype<'a> {
+pub struct BuiltinPrototype<'a> {
   name: &'static str,
   string_keyed: FxHashMap<&'static str, Entity<'a>>,
   symbol_keyed: FxHashMap<SymbolId, Entity<'a>>,
 }
 
-impl<'a> fmt::Debug for Prototype<'a> {
+impl<'a> fmt::Debug for BuiltinPrototype<'a> {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     f.write_str(format!("Prototype({})", self.name).as_str())
   }
 }
 
-impl<'a> Prototype<'a> {
+impl<'a> BuiltinPrototype<'a> {
   pub fn with_name(mut self, name: &'static str) -> Self {
     self.name = name;
     self
@@ -91,17 +91,17 @@ impl<'a> Prototype<'a> {
 }
 
 pub struct BuiltinPrototypes<'a> {
-  pub array: Prototype<'a>,
-  pub bigint: Prototype<'a>,
-  pub boolean: Prototype<'a>,
-  pub function: Prototype<'a>,
-  pub null: Prototype<'a>,
-  pub number: Prototype<'a>,
-  pub object: Prototype<'a>,
-  pub promise: Prototype<'a>,
-  pub regexp: Prototype<'a>,
-  pub string: Prototype<'a>,
-  pub symbol: Prototype<'a>,
+  pub array: BuiltinPrototype<'a>,
+  pub bigint: BuiltinPrototype<'a>,
+  pub boolean: BuiltinPrototype<'a>,
+  pub function: BuiltinPrototype<'a>,
+  pub null: BuiltinPrototype<'a>,
+  pub number: BuiltinPrototype<'a>,
+  pub object: BuiltinPrototype<'a>,
+  pub promise: BuiltinPrototype<'a>,
+  pub regexp: BuiltinPrototype<'a>,
+  pub string: BuiltinPrototype<'a>,
+  pub symbol: BuiltinPrototype<'a>,
 }
 
 impl<'a> Builtins<'a> {

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

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

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_number_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_number_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Number", create_object_prototype(factory), {
     "toExponential" => factory.pure_fn_returns_string,
     "toFixed" => factory.pure_fn_returns_string,

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

@@ -1,7 +1,7 @@
-use super::{null::create_null_prototype, Prototype};
+use super::{null::create_null_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_object_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_object_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Object", create_null_prototype(factory), {
     "constructor" => factory.immutable_unknown,
     "hasOwnProperty" => factory.pure_fn_returns_boolean,

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_promise_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_promise_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Promise", create_object_prototype(factory), {
     "finally" => factory.immutable_unknown,
     "then" => factory.immutable_unknown,

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_regexp_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_regexp_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("RegExp", create_object_prototype(factory), {
     "exec" => factory.pure_fn_returns_unknown,
     "test" => factory.pure_fn_returns_boolean,

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_string_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_string_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("String", create_object_prototype(factory), {
     "anchor" => factory.pure_fn_returns_string,
     "at" => factory.pure_fn_returns_unknown,

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

@@ -1,7 +1,7 @@
-use super::{object::create_object_prototype, Prototype};
+use super::{object::create_object_prototype, BuiltinPrototype};
 use crate::{entity::EntityFactory, init_prototype};
 
-pub fn create_symbol_prototype<'a>(factory: &EntityFactory<'a>) -> Prototype<'a> {
+pub fn create_symbol_prototype<'a>(factory: &EntityFactory<'a>) -> BuiltinPrototype<'a> {
   init_prototype!("Symbol", create_object_prototype(factory), {
     "toString" => factory.pure_fn_returns_string,
     "valueOf" => factory.pure_fn_returns_symbol,

crates/tree_shaker/src/consumable/collector.rs

@@ -46,8 +46,8 @@ impl<'a, T: ConsumableTrait<'a> + 'a> ConsumableCollector<'a, T> {
     self.try_collect(factory).unwrap_or(factory.empty_consumable)
   }
 
-  pub fn consume_all(self, analyzer: &mut Analyzer<'a>) {
-    for value in self.current {
+  pub fn consume_all(&self, analyzer: &mut Analyzer<'a>) {
+    for value in &self.current {
       value.consume(analyzer);
     }
 

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);
   }

crates/tree_shaker/src/entity/arguments.rs

@@ -1,5 +1,6 @@
 use super::{
-  consumed_object, Entity, EntityTrait, EnumeratedProperties, IteratedElements, TypeofResult,
+  consumed_object, Entity, EntityTrait, EnumeratedProperties, IteratedElements, ObjectPrototype,
+  TypeofResult,
 };
 use crate::{analyzer::Analyzer, consumable::Consumable, use_consumed_flag};
 use std::cell::Cell;
@@ -141,6 +142,14 @@ impl<'a> EntityTrait<'a> for ArgumentsEntity<'a> {
     unreachable!()
   }
 
+  fn get_constructor_prototype(
+    &'a self,
+    _analyzer: &Analyzer<'a>,
+    _dep: Consumable<'a>,
+  ) -> Option<(Consumable<'a>, ObjectPrototype<'a>, ObjectPrototype<'a>)> {
+    unreachable!()
+  }
+
   fn test_typeof(&self) -> TypeofResult {
     unreachable!()
   }

crates/tree_shaker/src/entity/builtin_fn.rs

@@ -1,6 +1,6 @@
 use super::{
   consumed_object, never::NeverEntity, Entity, EntityFactory, EntityTrait, EnumeratedProperties,
-  IteratedElements, ObjectEntity, TypeofResult,
+  IteratedElements, ObjectEntity, ObjectPrototype, TypeofResult,
 };
 use crate::{analyzer::Analyzer, consumable::Consumable};
 use std::fmt::Debug;
@@ -150,6 +150,14 @@ impl<'a, T: BuiltinFnEntity<'a>> EntityTrait<'a> for T {
     analyzer.factory.string("")
   }
 
+  fn get_constructor_prototype(
+    &'a self,
+    _analyzer: &Analyzer<'a>,
+    _dep: Consumable<'a>,
+  ) -> Option<(Consumable<'a>, ObjectPrototype<'a>, ObjectPrototype<'a>)> {
+    todo!()
+  }
+
   fn test_typeof(&self) -> TypeofResult {
     TypeofResult::Function
   }
@@ -217,7 +225,7 @@ impl<'a> Analyzer<'a> {
       #[cfg(feature = "flame")]
       name: _name,
       implementation,
-      object: Some(self.new_function_object()),
+      object: Some(self.new_function_object(None).0),
     })
   }
 }

crates/tree_shaker/src/entity/class.rs

@@ -2,12 +2,9 @@ use super::{
   consumed_object, Entity, EntityTrait, EnumeratedProperties, IteratedElements, ObjectEntity,
   TypeofResult,
 };
-use crate::{
-  analyzer::Analyzer, consumable::Consumable, module::ModuleId, scope::VariableScopeId,
-  use_consumed_flag,
-};
+use crate::{analyzer::Analyzer, consumable::Consumable, module::ModuleId, use_consumed_flag};
 use oxc::ast::ast::Class;
-use std::{cell::Cell, rc::Rc};
+use std::cell::Cell;
 
 #[derive(Debug)]
 pub struct ClassEntity<'a> {
@@ -16,8 +13,7 @@ pub struct ClassEntity<'a> {
   pub node: &'a Class<'a>,
   pub keys: Vec<Option<Entity<'a>>>,
   pub statics: &'a ObjectEntity<'a>,
-  pub super_class: Option<Entity<'a>>,
-  pub variable_scope_stack: Rc<Vec<VariableScopeId>>,
+  pub prototype: &'a ObjectEntity<'a>,
 }
 
 impl<'a> EntityTrait<'a> for ClassEntity<'a> {

crates/tree_shaker/src/entity/computed.rs

@@ -1,5 +1,6 @@
 use super::{
-  Entity, EntityTrait, EnumeratedProperties, IteratedElements, LiteralEntity, TypeofResult,
+  Entity, EntityTrait, EnumeratedProperties, IteratedElements, LiteralEntity, ObjectPrototype,
+  TypeofResult,
 };
 use crate::{
   analyzer::Analyzer,
@@ -137,6 +138,16 @@ impl<'a, T: ConsumableTrait<'a> + Copy + 'a> EntityTrait<'a> for ComputedEntity<
     self.val.get_own_keys(analyzer)
   }
 
+  fn get_constructor_prototype(
+    &'a self,
+    analyzer: &Analyzer<'a>,
+    dep: Consumable<'a>,
+  ) -> Option<(Consumable<'a>, ObjectPrototype<'a>, ObjectPrototype<'a>)> {
+    let (dep, statics, prototype) = self.val.get_constructor_prototype(analyzer, dep)?;
+    let dep = self.forward_dep(dep, analyzer);
+    Some((dep, statics, prototype))
+  }
+
   fn test_typeof(&self) -> TypeofResult {
     self.val.test_typeof()
   }