perf: avoid redundant PathBuf allocations in resolve paths (#8435)

Brooooooklyn · Brooooooklyn · commit 5f4bde97115d · 2026-02-24T15:06:43.000Z
- Skip `cwd.join(importer)` when importer is already an absolute path, passing `&Path` directly to `resolve_file()` instead of allocating a new PathBuf (~50K avoided allocations per 10K module build) - Apply the same optimization in rolldown_plugin_vite_resolve (2 sites) - Point oxc_resolver to local path for coordinated optimization Combined with the oxc-resolver changes oxc-project/oxc-resolver#1027, this eliminates ~174K `to_path_buf` allocations (21.3 MB) down to effectively zero, yielding ~9% faster JS API median on a 10K module benchmark. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>  --- > [!NOTE] > **Low Risk** > Small, localized change to how importer paths are passed into the resolver; primary risk is subtle behavior differences if callers pass unusual absolute/relative importer strings. > > **Overview** > Reduces resolve-time allocations by detecting when an `importer` is already an absolute path and calling `resolve_file(importer, ...)` directly instead of `cwd.join(importer)`/`root.join(importer)`. > > Applies this optimization in `rolldown_resolver::Resolver::resolve` and in two resolution paths in `rolldown_plugin_vite_resolve::Resolver::resolve_raw` (including the `try_prefix` fallback). > > <sup>Written by [Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit 51016de. This will update automatically on new commits. Configure [here](https://cursor.com/dashboard?tab=bugbot).</sup>
diff --git a/crates/rolldown_plugin_vite_resolve/src/resolver.rs b/crates/rolldown_plugin_vite_resolve/src/resolver.rs
@@ -281,7 +281,12 @@ impl Resolver {
 
     let inner_resolver = if external { &self.inner_for_external } else { &self.inner };
     let result = if let Some(importer) = importer {
-      inner_resolver.resolve_file(self.root.join(importer), specifier)
+      // check if `is_absolute` to avoid extra `join` overhead
+      if Path::new(importer).is_absolute() {
+        inner_resolver.resolve_file(importer, specifier)
+      } else {
+        inner_resolver.resolve_file(self.root.join(importer), specifier)
+      }
     } else {
       inner_resolver.resolve(&self.root, specifier)
     };
@@ -321,7 +326,12 @@ impl Resolver {
     // this allows resolving `@pkg/pkg/foo.scss` to `@pkg/pkg/_foo.scss`, which is probably not allowed by sass's resolver
     // but that's an edge case so we ignore it here
     if let Some(importer) = importer {
-      inner_resolver.resolve_file(self.root.join(importer), path_with_prefix)
+      // check if `is_absolute` to avoid extra `join` overhead
+      if Path::new(importer).is_absolute() {
+        inner_resolver.resolve_file(importer, path_with_prefix)
+      } else {
+        inner_resolver.resolve_file(self.root.join(importer), path_with_prefix)
+      }
     } else {
       inner_resolver.resolve(&self.root, path_with_prefix)
     }
diff --git a/crates/rolldown_resolver/src/resolver.rs b/crates/rolldown_resolver/src/resolver.rs
@@ -151,7 +151,12 @@ impl<Fs: FileSystem> Resolver<Fs> {
     };
 
     let mut resolution = if let Some(importer) = importer {
-      selected_resolver.resolve_file(self.cwd.join(importer), specifier)
+      // check if `is_absolute` to avoid extra `join` overhead
+      if importer.is_absolute() {
+        selected_resolver.resolve_file(importer, specifier)
+      } else {
+        selected_resolver.resolve_file(self.cwd.join(importer), specifier)
+      }
     } else {
       selected_resolver.resolve(self.cwd.as_path(), specifier)
     };
