fix: inner graph class static block usage (#12114)

Author: ahabhgk

crates/rspack_plugin_javascript/src/parser_plugin/common_js_exports_parse_plugin.rs

@@ -402,6 +402,7 @@ impl JavascriptParserPlugin for CommonJsExportsParserPlugin {
     &self,
     parser: &mut JavascriptParser,
     expr: &swc_core::ecma::ast::ThisExpr,
+    _for_name: &str,
   ) -> Option<bool> {
     if self.should_skip_handler(parser) {
       return None;

crates/rspack_plugin_javascript/src/parser_plugin/drive.rs

@@ -454,9 +454,10 @@ impl JavascriptParserPlugin for JavaScriptParserPluginDrive {
     &self,
     parser: &mut JavascriptParser,
     expr: &swc_core::ecma::ast::ThisExpr,
+    for_name: &str,
   ) -> Option<bool> {
     for plugin in &self.plugins {
-      let res = plugin.this(parser, expr);
+      let res = plugin.this(parser, expr, for_name);
       // `SyncBailHook`
       if res.is_some() {
         return res;

crates/rspack_plugin_javascript/src/parser_plugin/esm_top_level_this_plugin.rs

@@ -10,6 +10,7 @@ impl JavascriptParserPlugin for ESMTopLevelThisParserPlugin {
     &self,
     parser: &mut JavascriptParser,
     expr: &swc_core::ecma::ast::ThisExpr,
+    _for_name: &str,
   ) -> Option<bool> {
     (parser.is_esm && parser.is_top_level_this()).then(|| {
       parser.add_presentational_dependency(Box::new(ConstDependency::new(

crates/rspack_plugin_javascript/src/parser_plugin/inner_graph/plugin.rs

@@ -20,7 +20,8 @@ use crate::{
     is_pure_class, is_pure_class_member, is_pure_expression, is_pure_function,
   },
   visitors::{
-    JavascriptParser, Statement, TagInfoData, VariableDeclaration, scope_info::VariableInfoFlags,
+    ExportedVariableInfo, JavascriptParser, Statement, TagInfoData, VariableDeclaration,
+    scope_info::VariableInfoFlags,
   },
 };
 
@@ -639,19 +640,42 @@ impl JavascriptParserPlugin for InnerGraphPlugin {
   fn class_body_element(
     &self,
     parser: &mut JavascriptParser,
-    _element: &swc_core::ecma::ast::ClassMember,
+    element: &ClassMember,
     class_decl_or_expr: crate::visitors::ClassDeclOrExpr,
   ) -> Option<bool> {
     if !parser.inner_graph.is_enabled() || !parser.is_top_level_scope() {
       return None;
     }
-
-    if parser
+    if let Some(top_level_symbol) = parser
       .inner_graph
       .class_with_top_level_symbol
-      .contains_key(&class_decl_or_expr.span())
+      .get(&class_decl_or_expr.span())
     {
+      let top_level_symbol_variable_name = top_level_symbol.name.clone();
       parser.inner_graph.set_top_level_symbol(None);
+      /*
+       * ```js
+       * var A = class B {
+       *   static {
+       *     this;
+       *     B;
+       *   }
+       * }
+       * ```
+       * Alias `this` and `B` (class ident) to top level symbol `A` here, so `A` is used if `this` or `B`
+       * is used in static block (`add_usage` in identifier hook and this hook), even `A` is not used in
+       * any other place.
+       */
+      if let ClassMember::StaticBlock(_) = element {
+        let class_var = parser
+          .get_variable_info(&top_level_symbol_variable_name)
+          .map(|info| ExportedVariableInfo::VariableInfo(info.id()))
+          .unwrap_or(ExportedVariableInfo::Name(top_level_symbol_variable_name));
+        if let Some(class_ident) = class_decl_or_expr.ident() {
+          parser.set_variable(class_ident.sym.clone(), class_var.clone());
+        }
+        parser.set_variable("this".into(), class_var);
+      }
     }
 
     None
@@ -804,4 +828,14 @@ impl JavascriptParserPlugin for InnerGraphPlugin {
     Self::for_each_expression(parser, for_name);
     None
   }
+
+  fn this(
+    &self,
+    parser: &mut JavascriptParser,
+    _expr: &swc_core::ecma::ast::ThisExpr,
+    for_name: &str,
+  ) -> Option<bool> {
+    Self::for_each_expression(parser, for_name);
+    None
+  }
 }

crates/rspack_plugin_javascript/src/parser_plugin/side_effects_parser_plugin.rs

@@ -454,8 +454,8 @@ pub fn is_pure_class(
       }
       ClassMember::TsIndexSignature(_) => unreachable!(),
       ClassMember::Empty(_) => true,
-      ClassMember::StaticBlock(_) => true,
-      ClassMember::AutoAccessor(_) => true,
+      ClassMember::StaticBlock(_) => false, // TODO: support is pure analyze for statements
+      ClassMember::AutoAccessor(_) => false,
     }
   })
 }

crates/rspack_plugin_javascript/src/parser_plugin/trait.rs

@@ -302,7 +302,12 @@ pub trait JavascriptParserPlugin {
     None
   }
 
-  fn this(&self, _parser: &mut JavascriptParser, _expr: &ThisExpr) -> Option<bool> {
+  fn this(
+    &self,
+    _parser: &mut JavascriptParser,
+    _expr: &ThisExpr,
+    _for_name: &str,
+  ) -> Option<bool> {
     None
   }
 

crates/rspack_plugin_javascript/src/visitors/dependency/parser/walk.rs

@@ -488,8 +488,9 @@ impl JavascriptParser<'_> {
   }
 
   fn walk_this_expression(&mut self, expr: &ThisExpr) {
-    // TODO: `this.hooks.call_hooks_for_names`
-    self.plugin_drive.clone().this(self, expr);
+    "this".call_hooks_name(self, |this, for_name| {
+      this.plugin_drive.clone().this(this, expr, for_name)
+    });
   }
 
   pub(crate) fn walk_template_expression(&mut self, expr: &Tpl) {
@@ -1533,9 +1534,12 @@ impl JavascriptParser<'_> {
       self.walk_expression(super_class);
     }
 
-    let scope_params = if let Some(pat) = class_decl_or_expr
-      .ident()
-      .map(|ident| warp_ident_to_pat(ident.clone()))
+    // TODO: define variable for class expression in block pre walk
+    let scope_params = if let ClassDeclOrExpr::Expr(class_expr) = class_decl_or_expr
+      && let Some(pat) = class_expr
+        .ident
+        .as_ref()
+        .map(|ident| warp_ident_to_pat(ident.clone()))
     {
       vec![Cow::Owned(pat)]
     } else {

tests/rspack-test/normalCases/inner-graph/class-static-block/class.js

@@ -0,0 +1,35 @@
+import { a, b, c, d } from "./module"
+
+let _A;
+class A {
+  static {
+    _A = A;
+  }
+  prop = a();
+}
+
+let _B;
+class B {
+  static {
+    _B = this;
+  }
+  prop = b();
+}
+
+let _C;
+let __C = class C {
+  static {
+    _C = this;
+  }
+  prop = c();
+}
+
+let _D;
+let __D = class D {
+  static {
+    _D = D;
+  }
+  prop = d();
+}
+
+export { _A, _B, _C, _D };

tests/rspack-test/normalCases/inner-graph/class-static-block/index.js

@@ -0,0 +1,8 @@
+import { _A, _B, _C, _D } from "./class";
+
+it("should handle class static block correctly", () => {
+	expect((new _A()).prop).toBe("a");
+	expect((new _B()).prop).toBe("b");
+	expect((new _C()).prop).toBe("c");
+	expect((new _D()).prop).toBe("d");
+});

tests/rspack-test/normalCases/inner-graph/class-static-block/module.js

@@ -0,0 +1,4 @@
+export const a = () => "a";
+export const b = () => "b";
+export const c = () => "c";
+export const d = () => "d";