cleanup(core): cache compiled glob sets to avoid redundant recompilation (#34602)

## Current Behavior

`build_glob_set` recompiles identical glob pattern sets on every call,
even when the same set of patterns has been compiled before.

## Expected Behavior

Compiled `NxGlobSet` instances are cached in a static `DashMap` keyed by
sorted glob strings. Repeated calls with the same patterns return a
shared `Arc<NxGlobSet>` instead of recompiling. Profiling `nx run-many
-t build lint test --parallel 8` in the Nx repo measured 95.6% cache hit
rate (9,758 of 10,202 calls) with only 444 unique pattern sets, reducing
hashing-phase CPU by ~40%.

(cherry picked from commit 12812dc)

Author: leosvelperez

packages/nx/src/native/glob.rs

@@ -4,11 +4,15 @@ mod glob_parser;
 pub mod glob_transform;
 
 use crate::native::glob::glob_transform::convert_glob;
+use dashmap::DashMap;
 use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
 use std::fmt::Debug;
 use std::path::Path;
+use std::sync::{Arc, LazyLock};
 use tracing::trace;
 
+static GLOB_CACHE: LazyLock<DashMap<String, Arc<NxGlobSet>>> = LazyLock::new(DashMap::new);
+
 pub struct NxGlobSetBuilder {
     included_globs: GlobSetBuilder,
     excluded_globs: GlobSetBuilder,
@@ -89,7 +93,16 @@ fn potential_glob_split(
     }
 }
 
-pub(crate) fn build_glob_set<S: AsRef<str> + Debug>(globs: &[S]) -> anyhow::Result<NxGlobSet> {
+pub(crate) fn build_glob_set<S: AsRef<str> + Debug>(globs: &[S]) -> anyhow::Result<Arc<NxGlobSet>> {
+    // Build cache key from sorted globs joined by null byte (cannot appear in glob strings)
+    let mut sorted_globs: Vec<&str> = globs.iter().map(|s| s.as_ref()).collect();
+    sorted_globs.sort();
+    let cache_key = sorted_globs.join("\0");
+
+    if let Some(cached) = GLOB_CACHE.get(&cache_key) {
+        return Ok(Arc::clone(cached.value()));
+    }
+
     let result = globs
         .iter()
         .flat_map(|s| potential_glob_split(s.as_ref()))
@@ -106,7 +119,9 @@ pub(crate) fn build_glob_set<S: AsRef<str> + Debug>(globs: &[S]) -> anyhow::Resu
 
     trace!(?globs, ?result, "converted globs");
 
-    NxGlobSetBuilder::new(&result)?.build()
+    let glob_set = Arc::new(NxGlobSetBuilder::new(&result)?.build()?);
+    GLOB_CACHE.insert(cache_key, Arc::clone(&glob_set));
+    Ok(glob_set)
 }
 
 pub(crate) fn contains_glob_pattern(value: &str) -> bool {

packages/nx/src/native/utils/find_matching_projects.rs

@@ -160,19 +160,16 @@ fn add_matching_projects_by_name<'a>(
         return Ok(());
     }
 
-    get_matching_strings(
-        pattern.value,
-        &build_glob_set(&[pattern.value])?,
-        project_names,
-    )
-    .iter()
-    .for_each(|item| {
-        if pattern.exclude {
-            matched_projects.remove(item);
-        } else {
-            matched_projects.insert(item);
-        }
-    });
+    let glob = build_glob_set(&[pattern.value])?;
+    get_matching_strings(pattern.value, &glob, project_names)
+        .iter()
+        .for_each(|item| {
+            if pattern.exclude {
+                matched_projects.remove(item);
+            } else {
+                matched_projects.insert(item);
+            }
+        });
 
     Ok(())
 }

packages/nx/src/native/watch/watcher.rs

@@ -27,7 +27,7 @@ use watchexec_events::{Event, FileType, Priority, Tag};
 use watchexec_signals::Signal;
 
 /// Build the hardcoded ignore GlobSet used to check if new directories should be watched.
-fn build_ignore_glob_set() -> NxGlobSet {
+fn build_ignore_glob_set() -> Arc<NxGlobSet> {
     build_glob_set(HARDCODED_IGNORE_PATTERNS).expect("These static ignores always build")
 }
 
@@ -180,7 +180,7 @@ impl Watcher {
         // Hardcoded ignore patterns for dynamic directory registration.
         // These are always applied regardless of use_ignore - we never want to watch
         // node_modules, .git, etc. even when watching task outputs.
-        let ignore_globs: Arc<NxGlobSet> = Arc::new(build_ignore_glob_set());
+        let ignore_globs: Arc<NxGlobSet> = build_ignore_glob_set();
 
         let origin = self.origin.clone();
         let watch_exec_for_action = self.watch_exec.clone();