Summary

Each level of canonicalize_with_visited does one job: append the path's last component to whatever its parent canonicalized into — today via strip_prefix (O(len) component walk) + normalize_with (scratch-buffer copy of the whole path, full-path FxHash, dashmap shard probe).

When no ancestor is a symlink — the common case — the parent canonicalizes to itself, so that append can only rebuild the child's own key, and the shard probe is guaranteed to hand back the entry we already hold: four O(len) operations computing the identity function. This PR detects that case and returns the entry directly, per non-symlink level of every first-time canonicalization.

Example

pnpm project, node_modules/lodash → .pnpm/[email protected]/node_modules/lodash; canonicalize /app/node_modules/lodash/index.js (parent-first recursion):

• /app/node_modules: parent /app canonicalized to itself → the rebuild could only reproduce /app/node_modules → fast path returns the entry as-is. Most levels of most paths look like this.
• /app/node_modules/lodash: fast path for the string, then the (unchanged) symlink check lstats it, follows the link, and its canonical becomes the .pnpm entry.
• /app/node_modules/lodash/index.js: the parent's canonical is now a different entry → ptr_eq fails → the rebuild does real work, appending index.js to the .pnpm parent. The rebuild runs exactly where its output differs from its input.

Why the guard is sound

The cache interns paths — one Arc<CachedPathImpl> per byte string — so Arc::ptr_eq(&parent_canonical.0, &parent.0) ⟺ canonicalizing the parent changed nothing ⟺ no ancestor was rewritten by a symlink. Under that precondition the rebuild returns path's own Arc iff the rebuilt string is byte-identical to path's key. PathBuf::push of one normal component appends MAIN_SEPARATOR + name, except it appends no separator when the base already ends with one (a root). So the fast path is restricted to keys shaped exactly <parent><one native separator><file_name>, checked in O(1):

• file_name().is_some() — excludes ./.. tails, where the rebuild folds (/a/b/.. → /a);
• parent_len + 1 + name.len() == path_len — excludes trailing slashes and doubled separators mid-path;
• path_bytes[parent_len] == MAIN_SEPARATOR — excludes mixed joints on Windows (C:\proj/src, where push would emit \);
• path_bytes[parent_len − 1] != MAIN_SEPARATOR — excludes root-adjacent doubled separators (//x, C:\\x), where push appends no joint separator and the + 1 would otherwise count the doubled separator itself (caught in review; clean root children like /usr already failed the length check, so no fast-path coverage is lost);
• wasm always takes the rebuild: component normalization is what trims the trailing NULs uvwasi can leave in directory entries, and reusing the key verbatim would keep them.

Keys failing the guard are exactly the spellings the rebuild would fold rather than reproduce — they take the rebuild path as before. The symlink check on the resulting entry is unchanged; only the string computation is skipped.

Correctness

• canonicalize_matches_os_for_all_node_modules: 12,441 paths across 7 installed bench-pm combos (npm/pnpm/yarn/bun × flat/isolated/hoisted) match std::fs::canonicalize byte-for-byte.
• New canonicalize_dirty_cache_keys test covers every guard exclusion (./.. tails and mid-chain, trailing, doubled, and root-adjacent doubled separators on Unix and Windows) against the OS oracle. It compares OsStr bytes, because Path's component-based PartialEq treats //x and /x as equal and would mask separator-level differences; the root-adjacent cases fail on the unfixed fast path and pass with the guard.
• Full suite: 276 unit + 15 integration + 4 dependencies + 8 resolve_package + 13 doctests, clippy --deny warnings, fmt, on all CI platforms including Windows and big-endian.

Benchmarks

CodSpeed (instrumented instruction count, cold-cache pm workloads that exercise this path):

The flagged resolver_real[multi-thread] −6.2% is measurement slop: that bench reuses one resolver across iterations, so its steady state never reaches the changed code (the canonicalized OnceLock returns before the guard), and the same bench was untouched on e201289, which contains the identical fast path. Local wall-clock A/B (interleaved fixed binaries on a quiet machine, change measured first) agreed in direction: −1% to −3% on 7/8 pm combos, yarn-pnp neutral (dominated by .pnp.cjs parsing).

🤖 Generated with Claude Code