test(LibCast): observe the intermediate and pin the in-place contract

[thedavidmeister]

The four LibCast round trip tests each compared the input buffer against the
round trip of that same buffer. Because every cast is a pointer retype, both
sides of those assertions addressed one allocation, so the comparison held for
any cast that rewrote elements where they lay. Only a cast that returned a
different pointer could fail them, and nothing at all observed the intermediate
typed array — the value a caller of a single cast actually receives.

Two behaviours were therefore unpinned:

• Element preservation. A cast that masked uint256 words down to 160 bits
  while retyping them to address[] passed the whole suite.
• The in-place contract. All four casts, replaced with an implementation that
  returns a copy of the input rather than the input itself, passed the whole
  suite — even though "retype the data in place" is the documented contract and
  callers depend on the two names addressing one mutable structure.

The round trips are strengthened rather than duplicated: expected words are
snapshotted into an independent buffer before the cast, and the intermediate is
read directly, as a consumer of it would. Separate tests pin the in-place
contract itself, since nothing previously targeted it.

QA

• Discriminating tests: testAddressesArrayRound0, testAddressesArrayRound1, testBytes32ArrayRound0, testBytes32ArrayRound1 (strengthened in place), testAsAddressesArrayRetypesInPlace, testAsUint256ArrayFromAddressesRetypesInPlace, testAsBytes32ArrayRetypesInPlace, testAsUint256ArrayFromBytes32RetypesInPlace, testAsAddressesArrayWritesAreShared - each fails on base under its mutation and passes unmutated, verified by re-running mutation-probe over the same 13 mutants after the tests were added (13/13 killed, previously 8/13). Each compares an exact value, never a bare revert: the intermediate word against the full 256 bit input word, the returned pointer against the input pointer, and us[0] against the address written through addresses[0].

• Mutations applied: 13 against src/LibCast.sol, one behaviour each. addresses := us -> add(us, 0x20) (M01) -> testAddressesArrayRound0; addresses := us -> 0x60 (M02) -> testAddressesArrayRound0; addresses := us -> mask each element to 160 bits (M03, survived before) -> testAddressesArrayRound0; addresses := us -> allocate and copy (M04, survived before) -> testAsAddressesArrayRetypesInPlace and testAsAddressesArrayWritesAreShared; us := addresses -> add(addresses, 0x20) / 0x60 / copy (M05, M06, M07 - M07 survived before) -> testAddressesArrayRound0, testAddressesArrayRound1, testAsUint256ArrayFromAddressesRetypesInPlace; b32s := us -> add(us, 0x20) / 0x60 / copy (M08, M09, M10 - M10 survived before) -> testBytes32ArrayRound0, testBytes32ArrayRound1, testAsBytes32ArrayRetypesInPlace; us := b32s -> add(b32s, 0x20) / 0x60 / copy (M11, M12, M13 - M13 survived before) -> testBytes32ArrayRound0, testBytes32ArrayRound1, testAsUint256ArrayFromBytes32RetypesInPlace. Baseline green at both points: 6 tests before, 11 after.

• Oracle: the LibCast NatSpec and the README, not the implementation. The NatSpec states a cast "will merely retype the data in place, generally without additional checks" and that "the cast does NOT (can't) check that the input is a valid output ... It is the calling context that MUST ensure the validity of the data". The README states a cast "moves between Solidity types without changing the binary data". The in-place assertions and the assertion that upper bits survive unmasked are both derived from those statements, so the tests pin the documented contract rather than whatever the code happens to do.

• Category check: no issue drives this PR; it is the coverage half of an adversarial mutation test run over the whole repo, so the categories are the mutation catalog's. Exercised against this unit: side effects (delete/replace the write), constants and identifiers (pointer arithmetic on the retype), and returns/outputs (empty array, copied array). Conditionals, comparisons and filters/scopes do not occur in these four functions, which contain no branches. Test-only change; no source file is touched.

🤖 Generated with Claude Code

Summary by CodeRabbit

• Tests
  • Expanded coverage for in-place type conversions.
  • Added checks confirming data remains bit-for-bit intact, including address casts.
  • Verified converted arrays retain the original memory location.
  • Added coverage ensuring changes made through one array view are visible through another.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 225f7b4e-1fc9-49d4-836d-dce7fab65709

📥 Commits

Reviewing files that changed from the base of the PR and between a4692fd and 7a387a0.

📒 Files selected for processing (1)

• test/LibCast.t.sol

Included review availability: Your plan provides up to 1 included review per hour; 0 remain after this review.

---

Walkthrough

The LibCast tests now verify intermediate cast values, bit preservation, in-place array retyping, and shared storage between aliases.

Changes

LibCast array cast verification

Layer / File(s)	Summary
Cast value and bit preservation test/LibCast.t.sol	Round-trip tests use independent snapshots. They verify array lengths, intermediate elements, raw word preservation, and reverse casts for address, bytes32, and uint256 arrays.
In-place retyping and shared storage test/LibCast.t.sol	New tests verify that all cast directions return the original array pointer. A write through an address alias is also checked through the uint256 alias.

Estimated code review effort: 2 (Simple) | ~10 minutes

Merge Risk: ⚪ Minimal · up to 7a387

This test-only change strengthens coverage for LibCast value preservation and in-place behavior without changing production code or runtime behavior. No actionable merge-blocking risk remains beyond normal checks and review.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and concisely describes the strengthened LibCast tests and their in-place casting contract.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check. Docstring coverage is scoped to functions touched by this diff. Analyzed 0 functions across 0 files. (1 skipped: 1 unsupported.)
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch test/libcast-in-place-and-element-coverage

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}