perf: Resolve literal input paths via stat instead of glob walk (#11955)

## Summary

When tasks use `$TURBO_DEFAULT$` with additional literal inputs (like
`$TURBO_ROOT$/tsconfig.json`),
`get_package_file_hashes_from_inputs_and_index` was running every
include pattern through `compile_globs` (wax regex compilation) +
`walk_glob` (full directory traversal) — even for literal file paths
that resolve to exactly one file.

This separates literal paths from actual glob patterns. Literals get a
single `symlink_metadata` syscall. Only patterns with metacharacters
(`*`, `?`, `[`, `{`) go through the expensive compile + walk path.

## Impact

On a 630-package monorepo where the `typecheck` task includes
`$TURBO_ROOT$/tsconfig.json`, this eliminates ~990 out of 995 glob
compilations and directory walks.

**Profile data** (`turbo run typecheck --skip-infer --dry --profile`):

| Function | Before | After |
|----------|--------|-------|
| `walk_glob` | 51.5% (721ms) | 5.2% (68ms) |
| `compile_globs` | 28.5% (399ms) | <1% |
| Total spans | 18,148 | 15,164 |

**Hyperfine** (30 runs, `--warmup 10`, `typecheck --skip-infer --dry`):

| Repo | Optimized | Mainline | Ratio |
|------|-----------|----------|-------|
| Large (630 pkgs) | 1.623s ± 0.159s | 1.654s ± 0.168s | 1.02x |
| Medium (120 pkgs) | 821ms ± 66ms | 878ms ± 95ms | 1.07x |
| Small (5 pkgs) | 584ms ± 44ms | 589ms ± 108ms | 1.01x |

**Caveat**: Wall-clock improvement is within system noise on most runs.
The CPU time reduction is real and consistent (User time on the large
repo drops from ~1.96s to ~1.48s, a 25% reduction), but I/O and
system-time variance prevent it from reliably surfacing in hyperfine for
my machine.

Author: anthonyshew

crates/turborepo-globwalk/src/lib.rs

@@ -440,6 +440,24 @@ fn needs_path_cleaning(s: &str) -> bool {
     false
 }
 
+/// Returns true if the pattern contains glob metacharacters (*, ?, [, {).
+/// Literal file paths return false.
+pub fn is_glob_pattern(pattern: &str) -> bool {
+    // Check for unescaped glob metacharacters
+    let mut chars = pattern.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '\\' {
+            // Skip escaped character
+            chars.next();
+            continue;
+        }
+        if matches!(c, '*' | '?' | '[' | '{') {
+            return true;
+        }
+    }
+    false
+}
+
 pub fn globwalk_with_settings(
     base_path: &AbsoluteSystemPath,
     include: &[ValidatedGlob],

crates/turborepo-scm/src/package_deps.rs

@@ -267,15 +267,22 @@ impl GitRepo {
         // Include globs can find files not in the git index (e.g. gitignored files
         // that a user explicitly wants to track). Walk the filesystem for these
         // files but skip re-hashing any already known from the index.
+        //
+        // Optimization: separate literal file paths from actual glob patterns.
+        // Literal paths (e.g. "$TURBO_ROOT$/tsconfig.json") are resolved with a
+        // single stat syscall instead of compiling a glob regex and walking a
+        // directory tree.
         let pkg_prefix = package_path.to_unix();
 
         if !includes.is_empty() {
             let full_pkg_path = turbo_root.resolve(package_path);
             let package_unix_path = pkg_prefix.as_str();
 
             static CONFIG_FILES: &[&str] = &["package.json", "turbo.json", "turbo.jsonc"];
-            let mut inclusions = Vec::with_capacity(includes.len() + CONFIG_FILES.len());
-            let mut exclusions = Vec::new();
+
+            let mut glob_inclusions = Vec::new();
+            let mut glob_exclusions = Vec::new();
+            let mut literal_to_hash = Vec::new();
             let mut glob_buf = String::with_capacity(package_unix_path.len() + 1 + 64);
 
             let all = includes.iter().copied().chain(CONFIG_FILES.iter().copied());
@@ -285,44 +292,69 @@ impl GitRepo {
                     glob_buf.push_str(package_unix_path);
                     glob_buf.push('/');
                     glob_buf.push_str(exclusion.trim_start_matches('/'));
-                    exclusions.push(ValidatedGlob::from_str(&glob_buf)?);
+                    glob_exclusions.push(ValidatedGlob::from_str(&glob_buf)?);
+                } else if !globwalk::is_glob_pattern(raw_glob) {
+                    // Literal file path — resolve directly via stat instead of
+                    // compiling a glob and walking directories.
+                    let resolved =
+                        full_pkg_path.join_unix_path(turbopath::RelativeUnixPath::new(raw_glob)?);
+                    if resolved.symlink_metadata().is_ok() {
+                        let git_relative = self.root.anchor(&resolved)?.to_unix();
+                        let pkg_relative =
+                            turbopath::RelativeUnixPath::strip_prefix(&git_relative, &pkg_prefix)
+                                .ok()
+                                .map(|s| s.to_owned());
+                        let already_known = pkg_relative
+                            .as_ref()
+                            .is_some_and(|rel| hashes.contains_key(rel));
+                        if !already_known {
+                            literal_to_hash.push(git_relative);
+                        }
+                    }
                 } else {
                     glob_buf.push_str(package_unix_path);
                     glob_buf.push('/');
                     glob_buf.push_str(raw_glob.trim_start_matches('/'));
-                    inclusions.push(ValidatedGlob::from_str(&glob_buf)?);
+                    glob_inclusions.push(ValidatedGlob::from_str(&glob_buf)?);
                 }
             }
 
-            let files = globwalk::globwalk(
-                turbo_root,
-                &inclusions,
-                &exclusions,
-                globwalk::WalkType::Files,
-            )?;
-
-            // Only hash files not already present from the git index
-            let mut to_hash = Vec::new();
-            for entry in &files {
-                let git_relative = self.root.anchor(entry)?.to_unix();
-                let pkg_relative =
-                    turbopath::RelativeUnixPath::strip_prefix(&git_relative, &pkg_prefix)
-                        .ok()
-                        .map(|s| s.to_owned());
-
-                let already_known = pkg_relative
-                    .as_ref()
-                    .is_some_and(|rel| hashes.contains_key(rel));
-
-                if !already_known {
-                    to_hash.push(git_relative);
-                }
+            // Hash any literal files discovered via direct stat.
+            if !literal_to_hash.is_empty() {
+                let mut new_hashes = GitHashes::with_capacity(literal_to_hash.len());
+                hash_objects(&self.root, &full_pkg_path, literal_to_hash, &mut new_hashes)?;
+                hashes.extend(new_hashes);
             }
 
-            if !to_hash.is_empty() {
-                let mut new_hashes = GitHashes::with_capacity(to_hash.len());
-                hash_objects(&self.root, &full_pkg_path, to_hash, &mut new_hashes)?;
-                hashes.extend(new_hashes);
+            // Only do the expensive glob walk for patterns that are actual globs.
+            if !glob_inclusions.is_empty() {
+                let files = globwalk::globwalk(
+                    turbo_root,
+                    &glob_inclusions,
+                    &glob_exclusions,
+                    globwalk::WalkType::Files,
+                )?;
+
+                let mut to_hash = Vec::new();
+                for entry in &files {
+                    let git_relative = self.root.anchor(entry)?.to_unix();
+                    let pkg_relative =
+                        turbopath::RelativeUnixPath::strip_prefix(&git_relative, &pkg_prefix)
+                            .ok()
+                            .map(|s| s.to_owned());
+                    let already_known = pkg_relative
+                        .as_ref()
+                        .is_some_and(|rel| hashes.contains_key(rel));
+                    if !already_known {
+                        to_hash.push(git_relative);
+                    }
+                }
+
+                if !to_hash.is_empty() {
+                    let mut new_hashes = GitHashes::with_capacity(to_hash.len());
+                    hash_objects(&self.root, &full_pkg_path, to_hash, &mut new_hashes)?;
+                    hashes.extend(new_hashes);
+                }
             }
         }