refactor: FnCallInfo

Author: kermanx

crates/jsshaker/src/nodes/expr/arrow_function_expression.rs

@@ -6,12 +6,10 @@ use oxc::ast::{
 use crate::{
   analyzer::Analyzer,
   ast::{AstKind2, DeclarationKind},
-  dep::Dep,
   entity::Entity,
-  scope::VariableScopeId,
   transformer::Transformer,
-  utils::{CalleeInfo, CalleeNode},
-  value::{ArgumentsValue, cache::FnCacheTrackingData},
+  utils::CalleeNode,
+  value::{cache::FnCacheTrackingData, call::FnCallInfo},
 };
 
 impl<'a> Analyzer<'a> {
@@ -24,31 +22,31 @@ impl<'a> Analyzer<'a> {
 
   pub fn call_arrow_function_expression(
     &mut self,
-    callee: CalleeInfo<'a>,
-    call_dep: Dep<'a>,
     node: &'a ArrowFunctionExpression<'a>,
-    lexical_scope: Option<VariableScopeId>,
-    args: ArgumentsValue<'a>,
-    consume: bool,
+    info: FnCallInfo<'a>,
   ) -> (Entity<'a>, FnCacheTrackingData<'a>) {
     let runner = move |analyzer: &mut Analyzer<'a>| {
-      analyzer.push_call_scope(callee, call_dep, lexical_scope, node.r#async, false, consume);
+      analyzer.push_call_scope(info, node.r#async, false);
 
-      analyzer.exec_formal_parameters(&node.params, args, DeclarationKind::ArrowFunctionParameter);
+      analyzer.exec_formal_parameters(
+        &node.params,
+        info.args,
+        DeclarationKind::ArrowFunctionParameter,
+      );
       if node.expression {
         analyzer.exec_function_expression_body(&node.body);
       } else {
         analyzer.exec_function_body(&node.body);
       }
 
-      if consume {
+      if info.consume {
         analyzer.consume_return_values();
       }
 
       analyzer.pop_call_scope()
     };
 
-    if !consume && node.r#async {
+    if !info.consume && node.r#async {
       // Too complex to analyze the control flow, thus run exhaustively
       self.exec_async_or_generator_fn(move |analyzer| {
         runner(analyzer).0.consume(analyzer);

crates/jsshaker/src/nodes/misc/class.rs

@@ -13,12 +13,10 @@ use oxc::{
 use crate::{
   analyzer::Analyzer,
   ast::{AstKind2, DeclarationKind},
-  dep::Dep,
   entity::Entity,
-  scope::VariableScopeId,
   transformer::Transformer,
-  utils::{CalleeInfo, CalleeNode},
-  value::{ArgumentsValue, ObjectPrototype, ValueTrait, cache::FnCacheTrackingData},
+  utils::CalleeNode,
+  value::{ObjectPrototype, ValueTrait, cache::FnCacheTrackingData, call::FnCallInfo},
 };
 
 #[derive(Default)]
@@ -54,15 +52,6 @@ impl<'a> Analyzer<'a> {
     };
 
     // Enter class statics scope
-    let variable_scope = self.scoping.variable.top();
-    self.push_call_scope(
-      self.new_callee_info(CalleeNode::ClassStatics(node)),
-      self.factory.no_dep,
-      variable_scope,
-      false,
-      false,
-      false,
-    );
     self.variable_scope_mut().super_class =
       Some(data.super_class.unwrap_or(self.factory.undefined));
 
@@ -118,8 +107,6 @@ impl<'a> Analyzer<'a> {
       }
     }
 
-    self.pop_call_scope();
-
     let class = class.into();
     data.value = Some(class);
     class
@@ -139,23 +126,19 @@ impl<'a> Analyzer<'a> {
 
   pub fn call_class_constructor(
     &mut self,
-    callee: CalleeInfo<'a>,
-    call_dep: Dep<'a>,
     node: &'a Class<'a>,
-    lexical_scope: Option<VariableScopeId>,
-    this: Entity<'a>,
-    args: ArgumentsValue<'a>,
-    consume: bool,
+    info: FnCallInfo<'a>,
   ) -> (Entity<'a>, FnCacheTrackingData<'a>) {
     let factory = self.factory;
     let data = self.load_data::<Data>(AstKind2::Class(node));
 
-    self.push_call_scope(callee, call_dep, lexical_scope, false, false, consume);
+    self.push_call_scope(info, false, false);
     let super_class = data.super_class.unwrap_or(self.factory.undefined);
-    let body_scope = self.variable_scope_mut();
-    body_scope.this = Some(this);
-    body_scope.arguments = Some((args, factory.vec(/* later filled by formal parameters */)));
-    body_scope.super_class = Some(super_class);
+    let variable_scope = self.variable_scope_mut();
+    variable_scope.this = Some(info.this);
+    variable_scope.arguments =
+      Some((info.args, factory.vec(/* later filled by formal parameters */)));
+    variable_scope.super_class = Some(super_class);
 
     if let Some(id) = &node.id {
       self.declare_binding_identifier(id, false, DeclarationKind::NamedFunctionInBody);
@@ -168,7 +151,7 @@ impl<'a> Analyzer<'a> {
         && !node.r#static
       {
         let value = self.exec_property_definition(node);
-        this.set_property(self, self.factory.no_dep, key.unwrap(), value);
+        info.this.set_property(self, self.factory.no_dep, key.unwrap(), value);
       }
     }
 
@@ -177,15 +160,15 @@ impl<'a> Analyzer<'a> {
       let function = constructor.value.as_ref();
       let dep = self.factory.dep(AstKind2::Function(function));
       self.cf_scope_mut().push_dep(dep);
-      self.exec_formal_parameters(&function.params, args, DeclarationKind::FunctionParameter);
+      self.exec_formal_parameters(&function.params, info.args, DeclarationKind::FunctionParameter);
       self.exec_function_body(function.body.as_ref().unwrap());
-      if consume {
+      if info.consume {
         self.consume_return_values();
       }
       self.pop_call_scope()
     } else if let Some(super_class) = &data.super_class {
       self.pop_call_scope();
-      let ret_val = super_class.call(self, self.factory.no_dep, this, args);
+      let ret_val = super_class.call(self, self.factory.no_dep, info.this, info.args);
       (ret_val, FnCacheTrackingData::worst_case())
     } else {
       let (_, cache_tracking) = self.pop_call_scope();

crates/jsshaker/src/nodes/misc/function.rs

@@ -9,12 +9,10 @@ use oxc::{
 use crate::{
   analyzer::Analyzer,
   ast::{AstKind2, DeclarationKind},
-  dep::Dep,
   entity::Entity,
-  scope::VariableScopeId,
   transformer::Transformer,
-  utils::{CalleeInfo, CalleeNode},
-  value::{ArgumentsValue, cache::FnCacheTrackingData},
+  utils::CalleeNode,
+  value::{cache::FnCacheTrackingData, call::FnCallInfo},
 };
 
 impl<'a> Analyzer<'a> {
@@ -40,29 +38,17 @@ impl<'a> Analyzer<'a> {
 
   pub fn call_function(
     &mut self,
-    fn_entity: Entity<'a>,
-    callee: CalleeInfo<'a>,
-    call_dep: Dep<'a>,
     node: &'a Function<'a>,
-    lexical_scope: Option<VariableScopeId>,
-    this: Entity<'a>,
-    args: ArgumentsValue<'a>,
-    consume: bool,
+    info: FnCallInfo<'a>,
   ) -> (Entity<'a>, FnCacheTrackingData<'a>) {
     let runner = move |analyzer: &mut Analyzer<'a>| {
-      analyzer.push_call_scope(
-        callee,
-        call_dep,
-        lexical_scope,
-        node.r#async,
-        node.generator,
-        consume,
-      );
+      analyzer.push_call_scope(info, node.r#async, node.generator);
 
       let factory = analyzer.factory;
-      let body_scope = analyzer.variable_scope_mut();
-      body_scope.this = Some(this);
-      body_scope.arguments = Some((args, factory.vec(/* later filled by formal parameters */)));
+      let variable_scope = analyzer.variable_scope_mut();
+      variable_scope.this = Some(info.this);
+      variable_scope.arguments =
+        Some((info.args, factory.vec(/* later filled by formal parameters */)));
 
       let declare_in_body = node.r#type == FunctionType::FunctionExpression && node.id.is_some();
       if declare_in_body {
@@ -72,21 +58,21 @@ impl<'a> Analyzer<'a> {
           AstKind2::BindingIdentifier(id),
           false,
           DeclarationKind::NamedFunctionInBody,
-          Some(analyzer.factory.computed(fn_entity, AstKind2::BindingIdentifier(id))),
+          Some(analyzer.factory.computed(info.func.into(), AstKind2::BindingIdentifier(id))),
         );
       }
 
-      analyzer.exec_formal_parameters(&node.params, args, DeclarationKind::FunctionParameter);
+      analyzer.exec_formal_parameters(&node.params, info.args, DeclarationKind::FunctionParameter);
       analyzer.exec_function_body(node.body.as_ref().unwrap());
 
-      if consume {
+      if info.consume {
         analyzer.consume_return_values();
       }
 
       analyzer.pop_call_scope()
     };
 
-    if !consume && (node.r#async || node.generator) {
+    if !info.consume && (node.r#async || node.generator) {
       // Too complex to analyze the control flow, thus run exhaustively
       self.exec_async_or_generator_fn(move |analyzer| {
         runner(analyzer).0.consume(analyzer);

crates/jsshaker/src/scope/mod.rs

@@ -22,7 +22,7 @@ use crate::{
   module::ModuleId,
   scope::linked_tree::LinkedTree,
   utils::{CalleeInfo, CalleeNode},
-  value::{ObjectId, cache::FnCacheTrackingData},
+  value::{ObjectId, cache::FnCacheTrackingData, call::FnCallInfo},
 };
 
 pub struct Scoping<'a> {
@@ -106,33 +106,27 @@ impl<'a> Analyzer<'a> {
     self.scoping.variable.replace_top(new_top)
   }
 
-  pub fn push_call_scope(
-    &mut self,
-    callee: CalleeInfo<'a>,
-    call_dep: Dep<'a>,
-    lexical_scope: Option<VariableScopeId>,
-    is_async: bool,
-    is_generator: bool,
-    consume: bool,
-  ) {
+  pub fn push_call_scope(&mut self, info: FnCallInfo<'a>, is_async: bool, is_generator: bool) {
     let dep_id = DepAtom::from_counter();
-    if consume {
+    if info.consume {
       self.refer_dep(dep_id);
     }
 
-    self.module_stack.push(callee.module_id);
-    let old_variable_scope = self.replace_variable_scope(lexical_scope);
+    self.module_stack.push(info.func.callee.module_id);
+    let old_variable_scope_stack = self.replace_variable_scope(info.func.lexical_scope);
     let body_variable_scope = self.push_variable_scope();
     let cf_scope_depth = self.push_cf_scope_with_deps(
-      CfScopeKind::Function(self.allocator.alloc(FnCacheTrackingData::new_in(self.allocator))),
-      self.factory.vec1(self.dep((call_dep, dep_id))),
+      CfScopeKind::Function(
+        self.allocator.alloc(FnCacheTrackingData::new_in(self.allocator, info)),
+      ),
+      self.factory.vec1(self.dep((info.call_dep, dep_id))),
       false,
     );
 
     self.scoping.call.push(CallScope::new_in(
       dep_id,
-      callee,
-      old_variable_scope,
+      info.func.callee,
+      old_variable_scope_stack,
       cf_scope_depth,
       body_variable_scope,
       is_async,

crates/jsshaker/src/value/function/bound.rs

@@ -2,11 +2,8 @@ use oxc::span::Span;
 
 use crate::{
   Analyzer,
-  dep::Dep,
   entity::Entity,
-  scope::VariableScopeId,
-  utils::CalleeInfo,
-  value::{ArgumentsValue, cache::FnCacheTrackingData},
+  value::{ArgumentsValue, cache::FnCacheTrackingData, call::FnCallInfo},
 };
 
 #[derive(Debug)]
@@ -18,30 +15,23 @@ pub struct BoundFunction<'a> {
 }
 
 impl<'a> Analyzer<'a> {
-  pub fn call_bound_function(
+  pub fn call_bound_function<const IS_CTOR: bool>(
     &mut self,
-    callee: CalleeInfo<'a>,
-    call_dep: Dep<'a>,
     bound_fn: &'a BoundFunction<'a>,
-    lexical_scope: Option<VariableScopeId>,
-    ctor_this: Option<Entity<'a>>,
-    args: ArgumentsValue<'a>,
-    consume: bool,
+    info: FnCallInfo<'a>,
   ) -> (Entity<'a>, FnCacheTrackingData<'a>) {
-    self.push_call_scope(callee, call_dep, lexical_scope, false, false, consume);
+    self.push_call_scope(info, false, false);
 
-    // self.exec_formal_parameters(&node.params, args, DeclarationKind::ArrowFunctionParameter);
-    // if node.expression {
-    //   self.exec_function_expression_body(&node.body);
-    // } else {
-    //   self.exec_function_body(&node.body);
-    // }
-
-    let args = ArgumentsValue::from_concatenate(self, bound_fn.bound_args, args);
-    let ret = bound_fn.target.call(self, call_dep, ctor_this.unwrap_or(bound_fn.bound_this), args);
+    let args = ArgumentsValue::from_concatenate(self, bound_fn.bound_args, info.args);
+    let ret = bound_fn.target.call(
+      self,
+      info.call_dep,
+      if IS_CTOR { info.this } else { bound_fn.bound_this },
+      args,
+    );
     self.return_value(ret, self.factory.no_dep);
 
-    if consume {
+    if info.consume {
       self.consume_return_values();
     }