Test what a deletion sweep found nothing was watching

[martinus]

Closes #194.

--operators deletions removes whole statements rather than changing one token, and had never been run over the whole header. This is that run, the triage, and the outcome for each kind.

The run

	before	after
compiler	369	388
caught	185	199
hang	34	36
oom	2	2
survived	75	37
score		94% killed

665 mutants in 843s. Every fix below was confirmed by re-running the specific mutants, not assumed.

What survived, and why

#194 predicted two kinds, and both turned up — plus a third the issue did not anticipate.

1. Untested behaviour — the state a table carries (13)

A table carries four things besides its elements: the hasher, the key equality, the max load factor, and the size at which it calls itself full. Each is copied, moved or swapped by hand, one statement per member, in four separate places (copy assignment, both branches of move assignment, and swap). Every one of those statements was deletable with the suite green.

The reason is worth keeping: every existing test uses std::hash and std::equal_to, which are stateless — so a table that keeps its own hasher and one that takes the other's are indistinguishable. test/app/hashers.h gains a hasher and an equality carrying an inert tag, which is the smallest thing that makes the question askable. The tag takes no part in hashing, so swapping tables that carry different tags cannot change what either can find.

The full-threshold has no getter at all; it shows only in when the table rehashes, so it is pinned by bucket_count() holding still while the table demonstrably still has room.

2. Untested behaviour — overloads nothing ever called (5+17)

Two of the four at() overloads (const × transparent), transparent try_emplace with a hint, the iterator→const_iterator converting assignment (the construction is used everywhere; the assignment was not), and segmented_vector's free swap.

These now come back compiler rather than caught — deleting a return from a function that is genuinely instantiated does not build. That is a firmer kill than a failing assertion, and it is also the proof that they were previously uninstantiated: a deletion can only compile if nothing asks for the template.

Same shape for the 17 scalar hash<T> specializations, which were unchecked as a block: hash_char_types.cpp held one empty test case and a // TODO(martinus) make hash generic?. Losing one is invisible without looking — hash<T> silently falls back to the primary template, which forwards to std::hash and is not avalanching. Asserting both halves turns all seventeen into compile errors. The file is renamed hash_scalar_types.cpp, since it covers bool through unsigned long long, and that TODO is now implemented.

3. Real gaps in code that looked exercised (2)

• extract(iterator) walks the probe sequence from the key's home bucket, and the statement advancing that walk was removable. That can only mean the loop never went round once: every element every test extracted was already in its home bucket. A hash that sends every key to the same bucket makes the walk unavoidable. The mutant is now hang — without the advance it spins forever.
• max_load_factor() recomputes the full-threshold, and nothing noticed it missing, because every test set the factor on a table with no buckets yet, where there is nothing to recompute. Setting it on a populated table has to make the next insert grow.

4. Statements that do nothing (3)

wyhash zeroes a and b for the short-input cases, and both are already zero from std::uint64_t a{} / b{} — the empty-input branch existed only to assign zero to two variables already holding it.

This is provably the same function rather than merely an untested one: the golden values pin length 0 explicitly ("" → 0x42bc986dc5eec4d3) and the loop over lengths 0–200 covers the branch. So the branch is exercised; the statements simply have no effect. That is the distinction #194 asked for, and it is the reason this is a removal rather than a test.

What is left

37 survivors remain, filed as a follow-up issue with the triage attached. They are a different population from the 38 fixed here — mostly exception-recovery paths, if constexpr branches no tested type instantiates, and a handful that are provably unkillable: ~table() = default (identical to the implicit one), the two PREFETCH calls (a pure performance hint), and operator=='s &a == &b fast path (the general path returns the same answer). Those three are not test gaps and should not be chased; the sweep will report them every time.

Verification

590 test cases pass (up from 539), clang-format clean, and each group re-checked against the mutants it targets.

🤖 Generated with Claude Code