refactor: this compilation hook (#5960)

crates/node_binding/binding.d.ts

@@ -311,7 +311,6 @@ export interface JsExecuteModuleResult {
 }
 
 export interface JsHooks {
-  thisCompilation: (compilation: JsCompilation) => void
   afterProcessAssets: () => void
   emit: () => void
   assetEmitted: (asset: JsAssetEmittedArgs) => void
@@ -1283,6 +1282,7 @@ export interface RawTrustedTypes {
 export function registerGlobalTrace(filter: string, layer: "chrome" | "logger", output: string): void
 
 export interface RegisterJsTaps {
+  registerCompilerThisCompilationTaps: (stages: Array<number>) => Array<{ function: ((compilation: JsCompilation) => void); stage: number; }>
   registerCompilerCompilationTaps: (stages: Array<number>) => Array<{ function: ((compilation: JsCompilation) => void); stage: number; }>
   registerCompilerMakeTaps: (stages: Array<number>) => Array<{ function: ((compilation: JsCompilation) => Promise<void>); stage: number; }>
   registerCompilerShouldEmitTaps: (stages: Array<number>) => Array<{ function: ((compilation: JsCompilation) => boolean | undefined); stage: number; }>

crates/node_binding/src/hook.rs

@@ -5,7 +5,6 @@ use std::sync::RwLock;
 pub enum Hook {
   FinishMake,
   BuildModule,
-  ThisCompilation,
   AfterProcessAssets,
   Emit,
   AssetEmitted,
@@ -33,7 +32,6 @@ impl From<String> for Hook {
     match s.as_str() {
       "finishMake" => Hook::FinishMake,
       "buildModule" => Hook::BuildModule,
-      "thisCompilation" => Hook::ThisCompilation,
       "afterProcessAssets" => Hook::AfterProcessAssets,
       "emit" => Hook::Emit,
       "assetEmitted" => Hook::AssetEmitted,

crates/node_binding/src/plugins/interceptor.rs

@@ -8,8 +8,8 @@ use napi::{
 use rspack_binding_values::{JsBeforeResolveArgs, JsBeforeResolveOutput, JsCompilation};
 use rspack_core::{
   BeforeResolveArgs, Compilation, CompilationParams, CompilationProcessAssetsHook,
-  CompilerCompilationHook, CompilerMakeHook, CompilerShouldEmitHook, MakeParam,
-  NormalModuleFactoryBeforeResolveHook,
+  CompilerCompilationHook, CompilerMakeHook, CompilerShouldEmitHook, CompilerThisCompilationHook,
+  MakeParam, NormalModuleFactoryBeforeResolveHook,
 };
 use rspack_hook::{AsyncSeries, AsyncSeries2, AsyncSeriesBail, Hook, Interceptor};
 use rspack_napi::threadsafe_function::ThreadsafeFunction;
@@ -180,6 +180,10 @@ macro_rules! define_register {
 #[derive(Clone)]
 #[napi(object, object_to_js = false)]
 pub struct RegisterJsTaps {
+  #[napi(
+    ts_type = "(stages: Array<number>) => Array<{ function: ((compilation: JsCompilation) => void); stage: number; }>"
+  )]
+  pub register_compiler_this_compilation_taps: RegisterFunction<JsCompilation, ()>,
   #[napi(
     ts_type = "(stages: Array<number>) => Array<{ function: ((compilation: JsCompilation) => void); stage: number; }>"
   )]
@@ -203,6 +207,12 @@ pub struct RegisterJsTaps {
     RegisterFunction<JsBeforeResolveArgs, Promise<JsBeforeResolveOutput>>,
 }
 
+/* Compiler Hooks */
+define_register!(
+  RegisterCompilerThisCompilationTaps,
+  tap = CompilerThisCompilationTap<JsCompilation, ()> @ CompilerThisCompilationHook,
+  cache = false,
+);
 define_register!(
   RegisterCompilerCompilationTaps,
   tap = CompilerCompilationTap<JsCompilation, ()> @ CompilerCompilationHook,
@@ -219,18 +229,40 @@ define_register!(
   cache = false,
 );
 
+/* Compilation Hooks */
 define_register!(
   RegisterCompilationProcessAssetsTaps,
   tap = CompilationProcessAssetsTap<JsCompilation, Promise<()>> @ CompilationProcessAssetsHook,
   cache = false,
 );
 
+/* NormalModuleFactory Hooks */
 define_register!(
   RegisterNormalModuleFactoryBeforeResolveTaps,
   tap = NormalModuleFactoryBeforeResolveTap<JsBeforeResolveArgs, Promise<JsBeforeResolveOutput>> @ NormalModuleFactoryBeforeResolveHook,
   cache = true,
 );
 
+#[async_trait]
+impl AsyncSeries2<Compilation, CompilationParams> for CompilerThisCompilationTap {
+  async fn run(
+    &self,
+    compilation: &mut Compilation,
+    _: &mut CompilationParams,
+  ) -> rspack_error::Result<()> {
+    // SAFETY: `Compiler` will not be moved, as it's stored on the heap.
+    // The pointer to `Compilation` is valid for the lifetime of `Compiler`.
+    // `Compiler` is valid through the lifetime before it's closed by calling `Compiler.close()` or gc-ed.
+    // `JsCompilation` is valid through the entire lifetime of `Compilation`.
+    let compilation = unsafe { JsCompilation::from_compilation(compilation) };
+    self.function.call_with_sync(compilation).await
+  }
+
+  fn stage(&self) -> i32 {
+    self.stage
+  }
+}
+
 #[async_trait]
 impl AsyncSeries2<Compilation, CompilationParams> for CompilerCompilationTap {
   async fn run(

crates/node_binding/src/plugins/mod.rs

@@ -27,7 +27,8 @@ use rspack_hook::Hook as _;
 
 use self::interceptor::{
   RegisterCompilationProcessAssetsTaps, RegisterCompilerCompilationTaps, RegisterCompilerMakeTaps,
-  RegisterCompilerShouldEmitTaps, RegisterNormalModuleFactoryBeforeResolveTaps,
+  RegisterCompilerShouldEmitTaps, RegisterCompilerThisCompilationTaps,
+  RegisterNormalModuleFactoryBeforeResolveTaps,
 };
 use crate::{DisabledHooks, Hook, JsCompilation, JsHooks};
 
@@ -39,6 +40,7 @@ pub struct JsHooksAdapterInner {
 #[derive(Clone)]
 pub struct JsHooksAdapterPlugin {
   inner: Arc<JsHooksAdapterInner>,
+  register_compiler_this_compilation_taps: RegisterCompilerThisCompilationTaps,
   register_compiler_compilation_taps: RegisterCompilerCompilationTaps,
   register_compiler_make_taps: RegisterCompilerMakeTaps,
   register_compiler_should_emit_taps: RegisterCompilerShouldEmitTaps,
@@ -73,6 +75,11 @@ impl rspack_core::Plugin for JsHooksAdapterPlugin {
     ctx: PluginContext<&mut ApplyContext>,
     _options: &mut CompilerOptions,
   ) -> rspack_error::Result<()> {
+    ctx
+      .context
+      .compiler_hooks
+      .this_compilation
+      .intercept(self.register_compiler_this_compilation_taps.clone());
     ctx
       .context
       .compiler_hooks
@@ -105,24 +112,6 @@ impl rspack_core::Plugin for JsHooksAdapterPlugin {
     Ok(())
   }
 
-  async fn this_compilation(
-    &self,
-    args: rspack_core::ThisCompilationArgs<'_>,
-    _params: &rspack_core::CompilationParams,
-  ) -> rspack_core::PluginThisCompilationHookOutput {
-    if self.is_hook_disabled(&Hook::ThisCompilation) {
-      return Ok(());
-    }
-
-    // SAFETY: `Compiler` will not be moved, as it's stored on the heap.
-    // The pointer to `Compilation` is valid for the lifetime of `Compiler`.
-    // `Compiler` is valid through the lifetime before it's closed by calling `Compiler.close()` or gc-ed.
-    // `JsCompilation` is valid through the entire lifetime of `Compilation`.
-    let compilation = unsafe { JsCompilation::from_compilation(args.this_compilation) };
-
-    self.hooks.this_compilation.call(compilation).await
-  }
-
   async fn chunk_asset(&self, args: &ChunkAssetArgs) -> rspack_error::Result<()> {
     if self.is_hook_disabled(&Hook::ChunkAsset) {
       return Ok(());
@@ -489,6 +478,9 @@ impl JsHooksAdapterPlugin {
     register_js_taps: RegisterJsTaps,
   ) -> Result<Self> {
     Ok(JsHooksAdapterPlugin {
+      register_compiler_this_compilation_taps: RegisterCompilerThisCompilationTaps::new(
+        register_js_taps.register_compiler_this_compilation_taps,
+      ),
       register_compiler_compilation_taps: RegisterCompilerCompilationTaps::new(
         register_js_taps.register_compiler_compilation_taps,
       ),

crates/rspack_binding_values/src/hooks.rs

@@ -9,8 +9,6 @@ use crate::{
 
 #[napi(object, object_to_js = false)]
 pub struct JsHooks {
-  #[napi(ts_type = "(compilation: JsCompilation) => void")]
-  pub this_compilation: ThreadsafeFunction<JsCompilation, ()>,
   #[napi(ts_type = "() => void")]
   pub after_process_assets: ThreadsafeFunction<(), ()>,
   #[napi(ts_type = "() => void")]

crates/rspack_core/src/compiler/mod.rs

@@ -34,6 +34,8 @@ use crate::{
 use crate::{BoxPlugin, ExportInfo, UsageState};
 use crate::{CompilationParams, ContextModuleFactory, NormalModuleFactory};
 
+// should be SyncHook, but rspack need call js hook
+pub type CompilerThisCompilationHook = AsyncSeries2Hook<Compilation, CompilationParams>;
 // should be SyncHook, but rspack need call js hook
 pub type CompilerCompilationHook = AsyncSeries2Hook<Compilation, CompilationParams>;
 // should be AsyncParallelHook, but rspack need add MakeParam to incremental rebuild
@@ -43,6 +45,7 @@ pub type CompilerShouldEmitHook = AsyncSeriesBailHook<Compilation, bool>;
 
 #[derive(Debug, Default)]
 pub struct CompilerHooks {
+  pub this_compilation: CompilerThisCompilationHook,
   pub compilation: CompilerCompilationHook,
   pub make: CompilerMakeHook,
   pub should_emit: CompilerShouldEmitHook,
@@ -141,7 +144,9 @@ where
     // Fake this compilation as *currently* rebuilding does not create a new compilation
     self
       .plugin_driver
-      .this_compilation(&mut self.compilation, &compilation_params)
+      .compiler_hooks
+      .this_compilation
+      .call(&mut self.compilation, &mut compilation_params)
       .await?;
     self
       .plugin_driver

crates/rspack_core/src/plugin/api.rs

@@ -10,13 +10,13 @@ use tokio::sync::mpsc::UnboundedSender;
 use crate::{
   AdditionalChunkRuntimeRequirementsArgs, AdditionalModuleRequirementsArgs, AssetEmittedArgs,
   AssetInfo, BoxLoader, BoxModule, BuildTimeExecutionOption, Chunk, ChunkAssetArgs, ChunkHashArgs,
-  CodeGenerationResults, Compilation, CompilationHooks, CompilationParams, CompilerHooks,
-  CompilerOptions, ContentHashArgs, DependencyId, DoneArgs, FactorizeArgs, JsChunkHashArgs,
-  LoaderRunnerContext, Module, ModuleFactoryResult, ModuleIdentifier, ModuleType, NormalModule,
+  CodeGenerationResults, Compilation, CompilationHooks, CompilerHooks, CompilerOptions,
+  ContentHashArgs, DependencyId, DoneArgs, FactorizeArgs, JsChunkHashArgs, LoaderRunnerContext,
+  Module, ModuleFactoryResult, ModuleIdentifier, ModuleType, NormalModule,
   NormalModuleAfterResolveArgs, NormalModuleCreateData, NormalModuleFactoryHooks,
   OptimizeChunksArgs, ParserAndGenerator, PluginContext, ProcessAssetsArgs, RenderArgs,
   RenderChunkArgs, RenderManifestArgs, RenderModuleContentArgs, RenderStartupArgs, Resolver,
-  RuntimeModule, RuntimeRequirementsInTreeArgs, SourceType, ThisCompilationArgs,
+  RuntimeModule, RuntimeRequirementsInTreeArgs, SourceType,
 };
 
 #[derive(Debug, Clone)]
@@ -26,8 +26,6 @@ pub struct BeforeResolveArgs {
 }
 
 pub type PluginCompilationHookOutput = Result<()>;
-pub type PluginThisCompilationHookOutput = Result<()>;
-pub type PluginMakeHookOutput = Result<()>;
 pub type PluginBuildEndHookOutput = Result<()>;
 pub type PluginProcessAssetsHookOutput = Result<()>;
 pub type PluginReadResourceOutput = Result<Option<Content>>;
@@ -50,7 +48,6 @@ pub type PluginRenderModuleContentOutput<'a> = Result<RenderModuleContentArgs<'a
 pub type PluginRenderStartupHookOutput = Result<Option<BoxSource>>;
 pub type PluginRenderHookOutput = Result<Option<BoxSource>>;
 pub type PluginJsChunkHashHookOutput = Result<()>;
-pub type PluginShouldEmitHookOutput = Result<Option<bool>>;
 
 #[async_trait::async_trait]
 pub trait Plugin: Debug + Send + Sync {
@@ -66,14 +63,6 @@ pub trait Plugin: Debug + Send + Sync {
     Ok(())
   }
 
-  async fn this_compilation(
-    &self,
-    _args: ThisCompilationArgs<'_>,
-    _params: &CompilationParams,
-  ) -> PluginThisCompilationHookOutput {
-    Ok(())
-  }
-
   async fn done<'s, 'c>(
     &self,
     _ctx: PluginContext,

crates/rspack_core/src/plugin/args.rs

@@ -137,11 +137,6 @@ pub struct DoneArgs<'s, 'c: 's> {
   pub stats: &'s mut Stats<'c>,
 }
 
-#[derive(Debug)]
-pub struct ThisCompilationArgs<'c> {
-  pub this_compilation: &'c mut Compilation,
-}
-
 #[derive(Debug)]
 pub struct AdditionalChunkRuntimeRequirementsArgs<'a> {
   pub compilation: &'a mut Compilation,

crates/rspack_core/src/plugin/plugin_driver.rs

@@ -14,21 +14,20 @@ use crate::{
   AdditionalChunkRuntimeRequirementsArgs, AdditionalModuleRequirementsArgs, ApplyContext,
   AssetEmittedArgs, BeforeResolveArgs, BoxLoader, BoxModule, BoxedParserAndGeneratorBuilder,
   BuildTimeExecutionOption, Chunk, ChunkAssetArgs, ChunkContentHash, ChunkHashArgs,
-  CodeGenerationResults, Compilation, CompilationHooks, CompilationParams, CompilerHooks,
-  CompilerOptions, Content, ContentHashArgs, DependencyId, DoneArgs, FactorizeArgs,
-  JsChunkHashArgs, LoaderRunnerContext, Module, ModuleIdentifier, ModuleType, NormalModule,
-  NormalModuleAfterResolveArgs, NormalModuleCreateData, NormalModuleFactoryHooks,
-  OptimizeChunksArgs, Plugin, PluginAdditionalChunkRuntimeRequirementsOutput,
-  PluginAdditionalModuleRequirementsOutput, PluginBuildEndHookOutput, PluginChunkHashHookOutput,
-  PluginCompilationHookOutput, PluginContext, PluginFactorizeHookOutput,
-  PluginJsChunkHashHookOutput, PluginNormalModuleFactoryAfterResolveOutput,
-  PluginNormalModuleFactoryBeforeResolveOutput, PluginNormalModuleFactoryCreateModuleHookOutput,
-  PluginNormalModuleFactoryModuleHookOutput, PluginRenderChunkHookOutput, PluginRenderHookOutput,
-  PluginRenderManifestHookOutput, PluginRenderModuleContentOutput, PluginRenderStartupHookOutput,
-  PluginRuntimeRequirementsInTreeOutput, PluginThisCompilationHookOutput, ProcessAssetsArgs,
-  RenderArgs, RenderChunkArgs, RenderManifestArgs, RenderModuleContentArgs, RenderStartupArgs,
-  Resolver, ResolverFactory, RuntimeModule, RuntimeRequirementsInTreeArgs, Stats,
-  ThisCompilationArgs,
+  CodeGenerationResults, Compilation, CompilationHooks, CompilerHooks, CompilerOptions, Content,
+  ContentHashArgs, DependencyId, DoneArgs, FactorizeArgs, JsChunkHashArgs, LoaderRunnerContext,
+  Module, ModuleIdentifier, ModuleType, NormalModule, NormalModuleAfterResolveArgs,
+  NormalModuleCreateData, NormalModuleFactoryHooks, OptimizeChunksArgs, Plugin,
+  PluginAdditionalChunkRuntimeRequirementsOutput, PluginAdditionalModuleRequirementsOutput,
+  PluginBuildEndHookOutput, PluginChunkHashHookOutput, PluginCompilationHookOutput, PluginContext,
+  PluginFactorizeHookOutput, PluginJsChunkHashHookOutput,
+  PluginNormalModuleFactoryAfterResolveOutput, PluginNormalModuleFactoryBeforeResolveOutput,
+  PluginNormalModuleFactoryCreateModuleHookOutput, PluginNormalModuleFactoryModuleHookOutput,
+  PluginRenderChunkHookOutput, PluginRenderHookOutput, PluginRenderManifestHookOutput,
+  PluginRenderModuleContentOutput, PluginRenderStartupHookOutput,
+  PluginRuntimeRequirementsInTreeOutput, ProcessAssetsArgs, RenderArgs, RenderChunkArgs,
+  RenderManifestArgs, RenderModuleContentArgs, RenderStartupArgs, Resolver, ResolverFactory,
+  RuntimeModule, RuntimeRequirementsInTreeArgs, Stats,
 };
 
 pub struct PluginDriver {
@@ -149,27 +148,6 @@ impl PluginDriver {
 
     Ok(())
   }
-  /// Executed while initializing the compilation, right before emitting the compilation event. This hook is not copied to child compilers.
-  ///
-  /// See: https://webpack.js.org/api/compiler-hooks/#thiscompilation
-  pub async fn this_compilation(
-    &self,
-    compilation: &mut Compilation,
-    params: &CompilationParams,
-  ) -> PluginThisCompilationHookOutput {
-    for plugin in &self.plugins {
-      plugin
-        .this_compilation(
-          ThisCompilationArgs {
-            this_compilation: compilation,
-          },
-          params,
-        )
-        .await?;
-    }
-
-    Ok(())
-  }
 
   pub async fn content_hash(&self, args: &ContentHashArgs<'_>) -> Result<ChunkContentHash> {
     let mut result = HashMap::default();