perf(coverage): normalize a path with one fork instead of four

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.

[Chemaclass]

🤔 Background

Related #1102

normalize_path is what the DEBUG trap calls on every cache miss — 494 times
in a single run of one test file, because the caches live in shell variables
and each test body is a subshell. Its body was

echo"$(cd "$(dirname "$file")"&& pwd)/$(basename "$file")"

four command substitutions per call.

💡 Changes

• dirname/basename become parameter expansions, leaving one fork: 2081 ms → 424 ms per 500 calls, and a --coverage run of basic_test.sh6.4 s → 4.7 s with the same hit count
• cd+pwd stays deliberately: it resolves symlinks, so /tmp/x normalizes to /private/tmp/x on macOS the way the tracked roots expect. Pure string manipulation is faster still and would quietly stop matching them
• builtin printf, not printf, so a test spying printf cannot shadow a path the engine depends on — the Spying on printf breaks coverage collection #724 test caught exactly that during development

Note the issue's original premise (path mangling dominates) was wrong and is
corrected in the thread: the memo it proposed bought 4%, this buys 27%.