perf: napi communication (#11132)

Author: SyMind

Cargo.lock

@@ -615,17 +615,6 @@ export interface JsAfterEmitData {
   uid?: number
 }
 
-export interface JsAfterResolveData {
-  request: string
-  context: string
-  issuer: string
-  issuerLayer?: string
-  fileDependencies: Array<string>
-  contextDependencies: Array<string>
-  missingDependencies: Array<string>
-  createData?: JsCreateData
-}
-
 export interface JsAfterTemplateExecutionData {
   html: string
   headTags: Array<JsHtmlPluginTag>
@@ -2734,7 +2723,7 @@ export interface RegisterJsTaps {
   registerNormalModuleFactoryFactorizeTaps: (stages: Array<number>) => Array<{ function: ((arg: JsFactorizeArgs) => Promise<JsFactorizeArgs>); stage: number; }>
   registerNormalModuleFactoryResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveArgs) => Promise<JsResolveArgs>); stage: number; }>
   registerNormalModuleFactoryResolveForSchemeTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveForSchemeArgs) => Promise<[boolean | undefined, JsResolveForSchemeArgs]>); stage: number; }>
-  registerNormalModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsAfterResolveData) => Promise<[boolean | undefined, JsCreateData | undefined]>); stage: number; }>
+  registerNormalModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: string) => Promise<[boolean | undefined, JsCreateData | undefined]>); stage: number; }>
   registerNormalModuleFactoryCreateModuleTaps: (stages: Array<number>) => Array<{ function: ((arg: JsNormalModuleFactoryCreateModuleArgs) => Promise<void>); stage: number; }>
   registerContextModuleFactoryBeforeResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryBeforeResolveData) => Promise<false | JsContextModuleFactoryBeforeResolveData>); stage: number; }>
   registerContextModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryAfterResolveData) => Promise<false | JsContextModuleFactoryAfterResolveData>); stage: number; }>

crates/node_binding/napi-binding.d.ts

@@ -57,6 +57,7 @@ futures                                = { workspace = true }
 glob                                   = { workspace = true }
 heck                                   = { workspace = true }
 once_cell                              = { workspace = true }
+rayon                                  = { workspace = true }
 rspack_cacheable                       = { workspace = true }
 rspack_ids                             = { workspace = true }
 rspack_javascript_compiler             = { workspace = true }

crates/rspack_binding_api/Cargo.toml

@@ -1,4 +1,4 @@
-use std::sync::LazyLock;
+use std::{cell::RefCell, sync::LazyLock};
 
 use napi::{
   bindgen_prelude::{
@@ -150,9 +150,7 @@ impl BuildInfo {
   }
 }
 
-fn create_known_private_properties(env: &Env) -> napi::Result<Vec<Property>> {
-  let mut properties = vec![];
-
+fn create_known_private_properties(env: &Env, properties: &mut Vec<Property>) -> napi::Result<()> {
   BUILD_INFO_ASSETS_SYMBOL.with(|once_cell| {
     #[allow(clippy::unwrap_used)]
     let symbol = once_cell.get().unwrap();
@@ -264,7 +262,11 @@ fn create_known_private_properties(env: &Env) -> napi::Result<Vec<Property>> {
     Ok::<(), napi::Error>(())
   })?;
 
-  Ok(properties)
+  Ok(())
+}
+
+thread_local! {
+  static BUILD_INFO_PROPERTIES_BUFFER: RefCell<Vec<Property>> = const { RefCell::new(Vec::new()) };
 }
 
 impl ToNapiValue for BuildInfo {
@@ -278,59 +280,64 @@ impl ToNapiValue for BuildInfo {
     let napi_val = ToNapiValue::to_napi_value(env, known)?;
     let mut object = Object::from_raw(env, napi_val);
 
-    let mut properties = create_known_private_properties(&env_wrapper)?;
-
-    let commit_custom_fields_fn: napi::bindgen_prelude::Function<'_, (), ()> = env_wrapper
-      .create_function_from_closure("commitCustomFieldsToRust", |ctx| {
-        let object = ctx.this::<Object>()?;
-        let env = ctx.env;
-        let this: &mut KnownBuildInfo = FromNapiMutRef::from_napi_mut_ref(env.raw(), object.raw())?;
-
-        this.with_mut(|module| {
-          let mut extras = serde_json::Map::new();
-          let names = Array::from_unknown(object.get_property_names()?.to_unknown())?;
-          for index in 0..names.len() {
-            if let Some(name) = names.get::<String>(index)? {
-              if !KNOWN_BUILD_INFO_FIELD_NAMES.contains(name.as_str()) {
-                let value = object.get_named_property::<Unknown>(&name)?;
-                if let Some(json_value) = unknown_to_json_value(value)? {
-                  extras.insert(name, json_value);
+    BUILD_INFO_PROPERTIES_BUFFER.with(|ref_cell| {
+      let mut properties = ref_cell.borrow_mut();
+      properties.clear();
+      create_known_private_properties(&env_wrapper, &mut properties)?;
+
+      let commit_custom_fields_fn: napi::bindgen_prelude::Function<'_, (), ()> = env_wrapper
+        .create_function_from_closure("commitCustomFieldsToRust", |ctx| {
+          let object = ctx.this::<Object>()?;
+          let env = ctx.env;
+          let this: &mut KnownBuildInfo =
+            FromNapiMutRef::from_napi_mut_ref(env.raw(), object.raw())?;
+
+          this.with_mut(|module| {
+            let mut extras = serde_json::Map::new();
+            let names = Array::from_unknown(object.get_property_names()?.to_unknown())?;
+            for index in 0..names.len() {
+              if let Some(name) = names.get::<String>(index)? {
+                if !KNOWN_BUILD_INFO_FIELD_NAMES.contains(name.as_str()) {
+                  let value = object.get_named_property::<Unknown>(&name)?;
+                  if let Some(json_value) = unknown_to_json_value(value)? {
+                    extras.insert(name, json_value);
+                  }
                 }
               }
             }
-          }
 
-          module.build_info_mut().extras = extras;
-
-          Ok(())
-        })
+            module.build_info_mut().extras = extras;
+
+            Ok(())
+          })
+        })?;
+
+      val.with_ref(|module| {
+        let extras = &module.build_info().extras;
+        properties.reserve(extras.len() + 1);
+        for (key, value) in extras {
+          let napi_val = ToNapiValue::to_napi_value(env, value)?;
+          properties.push(
+            Property::new()
+              .with_utf8_name(key)?
+              .with_value(&Object::from_raw(env, napi_val)),
+          );
+        }
+        Ok(())
       })?;
-
-    val.with_ref(|module| {
-      let extras = &module.build_info().extras;
-      properties.reserve(extras.len() + 1);
-      for (key, value) in extras {
-        let napi_val = ToNapiValue::to_napi_value(env, value)?;
+      COMMIT_CUSTOM_FIELDS_SYMBOL.with(|once_cell| {
+        #[allow(clippy::unwrap_used)]
+        let symbol = once_cell.get().unwrap();
         properties.push(
           Property::new()
-            .with_utf8_name(key)?
-            .with_value(&Object::from_raw(env, napi_val)),
+            .with_name(&env_wrapper, symbol)?
+            .with_value(&commit_custom_fields_fn)
+            .with_property_attributes(PropertyAttributes::Configurable),
         );
-      }
-      Ok(())
-    })?;
-    COMMIT_CUSTOM_FIELDS_SYMBOL.with(|once_cell| {
-      #[allow(clippy::unwrap_used)]
-      let symbol = once_cell.get().unwrap();
-      properties.push(
-        Property::new()
-          .with_name(&env_wrapper, symbol)?
-          .with_value(&commit_custom_fields_fn)
-          .with_property_attributes(PropertyAttributes::Configurable),
-      );
-      Ok::<(), napi::Error>(())
+        Ok::<(), napi::Error>(())
+      })?;
+      object.define_properties(&properties)
     })?;
-    object.define_properties(&properties)?;
 
     Ok(napi_val)
   }

crates/rspack_binding_api/src/build_info.rs

@@ -163,21 +163,20 @@ impl JsCompilation {
   }
 
   #[napi(getter, ts_return_type = "Array<Module>")]
-  pub fn modules(&self) -> Result<Vec<ModuleObject>> {
+  pub fn modules<'a>(&self, env: &'a Env) -> Result<Array<'a>> {
     let compilation = self.as_ref()?;
-
-    Ok(
-      compilation
-        .get_module_graph()
-        .modules()
-        .keys()
-        .filter_map(|module_id| {
-          compilation
-            .module_by_identifier(module_id)
-            .map(|module| ModuleObject::with_ref(module.as_ref(), compilation.compiler_id()))
-        })
-        .collect::<Vec<_>>(),
-    )
+    let module_graph = compilation.get_module_graph();
+    let modules = module_graph.modules();
+    let mut arr = env.create_array(modules.len() as u32)?;
+    for (i, identifier) in modules.keys().enumerate() {
+      arr.set(
+        i as u32,
+        compilation
+          .module_by_identifier(identifier)
+          .map(|module| ModuleObject::with_ref(module.as_ref(), compilation.compiler_id())),
+      )?;
+    }
+    Ok(arr)
   }
 
   #[napi(getter, ts_return_type = "Array<Module>")]

crates/rspack_binding_api/src/compilation/mod.rs

@@ -1,6 +1,9 @@
 use std::{cell::RefCell, ptr::NonNull};
 
-use napi::{bindgen_prelude::ToNapiValue, Either, Env, JsString};
+use napi::{
+  bindgen_prelude::{Array, ToNapiValue},
+  Either, Env,
+};
 use napi_derive::napi;
 use rspack_core::{Compilation, CompilationId, DependencyId};
 use rspack_napi::OneShotInstanceRef;
@@ -123,36 +126,36 @@ impl Dependency {
     Ok(())
   }
 
-  #[napi(getter)]
-  pub fn ids<'a>(&mut self, env: &'a Env) -> napi::Result<Either<Vec<JsString<'a>>, ()>> {
+  #[napi(getter, ts_return_type = "Array<string> | undefined")]
+  pub fn ids<'a>(&mut self, env: &'a Env) -> napi::Result<Either<Array<'a>, ()>> {
     let (dependency, compilation) = self.as_ref()?;
 
     Ok(match compilation {
       Some(compilation) => {
         let module_graph = compilation.get_module_graph();
         if let Some(dependency) = dependency.downcast_ref::<CommonJsExportRequireDependency>() {
-          let ids = dependency
-            .get_ids(&module_graph)
-            .iter()
-            .map(|atom| env.create_string(atom.as_str()))
-            .collect::<napi::Result<Vec<_>>>()?;
-          Either::A(ids)
+          let ids = dependency.get_ids(&module_graph);
+          let mut arr = env.create_array(ids.len() as u32)?;
+          for (i, v) in ids.iter().enumerate() {
+            arr.set(i as u32, v.as_str())?;
+          }
+          Either::A(arr)
         } else if let Some(dependency) =
           dependency.downcast_ref::<ESMExportImportedSpecifierDependency>()
         {
-          let ids = dependency
-            .get_ids(&module_graph)
-            .iter()
-            .map(|atom| env.create_string(atom.as_str()))
-            .collect::<napi::Result<Vec<_>>>()?;
-          Either::A(ids)
+          let ids = dependency.get_ids(&module_graph);
+          let mut arr = env.create_array(ids.len() as u32)?;
+          for (i, v) in ids.iter().enumerate() {
+            arr.set(i as u32, v.as_str())?;
+          }
+          Either::A(arr)
         } else if let Some(dependency) = dependency.downcast_ref::<ESMImportSpecifierDependency>() {
-          let ids = dependency
-            .get_ids(&module_graph)
-            .iter()
-            .map(|atom| env.create_string(atom.as_str()))
-            .collect::<napi::Result<Vec<_>>>()?;
-          Either::A(ids)
+          let ids = dependency.get_ids(&module_graph);
+          let mut arr = env.create_array(ids.len() as u32)?;
+          for (i, v) in ids.iter().enumerate() {
+            arr.set(i as u32, v.as_str())?;
+          }
+          Either::A(arr)
         } else {
           Either::B(())
         }