feat(oxc_linter): reuse allocators

Author: camc314

crates/oxc_linter/src/lib.rs

@@ -14,6 +14,7 @@ mod globals;
 mod module_graph_visitor;
 mod module_record;
 mod options;
+mod pool;
 mod rule;
 mod service;
 mod utils;

crates/oxc_linter/src/pool.rs

@@ -0,0 +1,64 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+pub struct Pool<T> {
+    items: Arc<Mutex<VecDeque<T>>>,
+    factory: Arc<dyn Fn() -> T + Send + Sync>,
+}
+
+pub struct PoolGuard<T: PoolDrop> {
+    item: Option<T>,
+    pool: Arc<Mutex<VecDeque<T>>>,
+}
+
+impl<T: PoolDrop + Send> Pool<T> {
+    pub fn new<F>(factory: F) -> Self
+    where
+        F: Fn() -> T + Send + Sync + 'static,
+    {
+        Self { items: Arc::new(Mutex::new(VecDeque::new())), factory: Arc::new(factory) }
+    }
+
+    pub fn get(&self) -> PoolGuard<T> {
+        let item = {
+            let mut items = self.items.lock().unwrap();
+            items.pop_front().unwrap_or_else(|| (self.factory)())
+        };
+
+        PoolGuard { item: Some(item), pool: Arc::<Mutex<VecDeque<T>>>::clone(&self.items) }
+    }
+}
+
+impl<T: PoolDrop> std::ops::Deref for PoolGuard<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.item.as_ref().unwrap()
+    }
+}
+
+impl<T: PoolDrop> std::ops::DerefMut for PoolGuard<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.item.as_mut().unwrap()
+    }
+}
+
+pub trait PoolDrop {
+    fn drop_pool(&mut self);
+}
+
+impl PoolDrop for oxc_allocator::Allocator {
+    fn drop_pool(&mut self) {
+        self.reset();
+    }
+}
+
+impl<T: PoolDrop> Drop for PoolGuard<T> {
+    fn drop(&mut self) {
+        if let Some(mut item) = self.item.take() {
+            item.drop_pool();
+            let mut items = self.pool.lock().unwrap();
+            items.push_back(item);
+        }
+    }
+}

crates/oxc_linter/src/service/runtime.rs

@@ -28,6 +28,7 @@ use crate::{
     fixer::PossibleFixes,
     loader::{JavaScriptSource, LINT_PARTIAL_LOADER_EXTENSIONS, PartialLoader},
     module_record::ModuleRecord,
+    pool::{self, Pool},
     utils::read_to_string,
 };
 
@@ -42,6 +43,8 @@ pub struct Runtime<'l> {
     resolver: Option<Resolver>,
 
     pub(super) file_system: Box<dyn RuntimeFileSystem + Sync + Send>,
+
+    allocator_pool: Pool<Allocator>,
 }
 
 /// Output of `Runtime::process_path`
@@ -95,7 +98,7 @@ unsafe impl Send for ModuleContent {}
 
 struct ModuleContentOwner {
     source_text: String,
-    allocator: Allocator,
+    allocator: pool::PoolGuard<Allocator>,
 }
 
 /// source text and semantic for each source section. They are in the same order as `ProcessedModule.section_module_records`
@@ -165,6 +168,7 @@ impl<'l> Runtime<'l> {
             Self::get_resolver(options.tsconfig.or_else(|| Some(options.cwd.join("tsconfig.json"))))
         });
         Self {
+            allocator_pool: Pool::new(Allocator::default),
             cwd: options.cwd,
             paths: options.paths.iter().cloned().collect(),
             linter,
@@ -771,7 +775,9 @@ impl<'l> Runtime<'l> {
         };
         let mut records = SmallVec::<[Result<ResolvedModuleRecord, Vec<OxcDiagnostic>>; 1]>::new();
         let mut module_content: Option<ModuleContent> = None;
-        let allocator = Allocator::default();
+
+        let allocator = self.allocator_pool.get();
+
         if self.paths.contains(path) {
             module_content =
                 Some(ModuleContent::new(ModuleContentOwner { source_text, allocator }, |owner| {