feat: splittable_adapter_closure

[KSXGitHub]

Implements all three triggers of planned-rules/splittable-adapter-closure.md, as one rule, over nine families. The planning file survives the PR because some of it is deferred.

What fires

trigger	the closure holds	a lifted part goes into
chain	a chain of two or more steps rooted at the item	the adapter mapping the item's channel
predicate	a conjunction of two or more tests, each naming the item	filter or take_while, by discipline
guard and value	a call to an Option combinator or a bool::then	the combinator's counterpart, discipline-matched

headers.map(|header| header.trim().to_ascii_lowercase())   // chain
paths.filter(|path| path.is_file() && path.exists())       // predicate
lines.filter_map(|line| parse(line).and_then(validate))    // guard and value

The triggers are asked in that order and the first finding wins, so a body that is Option work gets the split handing each half to its counterpart, and any other body under the same adapter falls through to the chain's leading map.

Families reached: Iterator, DoubleEndedIterator, Option, Result, Poll, ControlFlow, Itertools, ParallelIterator and Pipe. The adapters in scope are the ones whose item enters the closure by value and never comes back out, which is what lets a leading lift mean the same thing. The tables are lists rather than type queries because the condition is about an adapter's contract, which no type exposes.

A conjunction is rewritten for you; the other two shapes are described. A conjunction splits one way and one way only, one adapter per test in the order they were written, so there is no text to choose. A chain and a guard-and-value body each have more than one reasonable text, so they stay advice for now.

The rewrite keeps the closure each test was written in rather than reducing it to a path. A path asks more of a test than the split does, and clippy::redundant_closure_for_method_calls, which this workspace enables, is the lint that reduces the ones that can be reduced. Measured across clippy::all, pedantic, nursery and restriction, nothing asks for the closure form back, so the two fixes compose in that order and stop. tests/splittable_adapter_closure_autofix.rs runs the real fixer over seven shapes and compares the whole file.

What it flags

Beyond the three shapes above, these are the ones whose being in scope is not obvious. Every split below was compiled and compared against its folded form in a scratch crate.

the closure holds	example	and splits although
a chain inside filter_map, find_map or map_while	lines.filter_map(|line| parse(line.trim()))	the adapter's own closure returns an Option
the same on itertools' Ok channel	items.filter_map_ok(|text| text.trim().parse().ok())	that channel is one level inside the iterator's
a chain under partition_map	lines.partition_map(|text| classify(text.trim()))	its closure returns an Either rather than the item
a chain under Option and Result's non-mapping adapters	value.and_then(|text| parse(text.trim()))	the lifted step's result stays wrapped in what the adapter keeps
a chain under Pipe's eight borrow-handing methods	value.pipe_ref(|text| text.trim().len())	a pipe hands a value where these hand a borrow
a conjunction holding one comparison	lines.filter(|line| wanted(line) && line.len() > 3)	comparisons bounding one quantity are one test
comparisons bounding two quantities	spans.filter(|span| span.offset >= start && span.length < limit)	they are spelled the way a single range check is
a step whose argument cannot have lent it anything	lines.map(|line| line.trim_start_matches("# ").len())	its result borrows, and the argument carries a region

Two of those needed more than a table entry. The piping methods perform their conversion once, at the head of the chain, so the first lifted step keeps the method and every step above the head takes a value; that also settles the receiver-move question, since such a split borrows the receiver exactly where the folded form did. And liftability reads the method's declared signature rather than the types the call instantiated, because the regions there are erased where the signature still names them: str::strip_prefix<P>(&self, prefix: P) -> Option<&str> shares none of them with its argument, where Ord::max(self, other: Self) -> Self shares Self.

Applying the rule to the crate's own source is the honest test of whether the diagnostics are wanted. Every site it flagged takes the split rather than an #[allow], and KSXGitHub/perfectionist#506 carries them one per row. The two ending and_then(Result::ok) take the Option sibling of the filter_map(Result::ok) shape src/cargo_manifest.rs already carries, which is the rewrite this rule was distilled from.

What it leaves alone

the closure holds	example	why
an item the closure owns, under a borrowing step	lines.map(|line: String| line.trim().len())	the lifted map ends before the borrow is used: E0515
a Copy item that is not a reference	rows.map(|row: [u8; 4]| row.as_slice().len())	the same, cheap copying notwithstanding
a later step applied to a value the step before it made	lines.map(|line| pick(line).into_iter().count())	a consumed receiver is not told from a borrowed one
a chain the closure does not always reach	.map(|s| if flag { s.trim().parse().unwrap() } else { 0 })	lifting runs it for every item rather than for some
an item named more than once	pairs.map(|pair| pair.trim().to_owned() + pair)	each step's own closure would leave the later mentions unbound
a step reaching a capture only one closure could hold	lines.map(|line| line.trim().len() + bump(&mut seen))	two closures cannot both hold it
comparisons bounding one quantity	positions.any(|pos| pos >= start && pos < end)	that is how Rust spells one test, whichever side the quantity falls on
a conjunct that does not name the item	lines.filter(|line| ready && line.len() > 3)	an invariant to hoist out of the pipeline, not a test to give an adapter
a disjunction	lines.filter(|line| wanted(line) || line.is_empty())	filtering on one alternative keeps items the pair would have dropped
an adapter that hands the item back	lines.filter(|line| line.trim().is_empty())	a leading map changes what it and every later adapter sees
an adapter whose answer is more than which items pass	lines.all(|line| wanted(line) && line.len() > 3)	filtering first makes a failing item vacuously fine
a receiver named again, under an adapter taking &mut self	let empty = lines.any(..); lines.count()	the split would move it, and the reborrow is not offered
a step, test or stage boundary inside an expansion	lines.filter_map(|line| staged!(line))	not a rewrite the reader can make
Result::map_or_else's error closure	outcome.map_or_else(|text| text.trim().len(), |value| value)	the table holds one adapter per method name
a borrowing stage, for the guard-and-value split	lines.filter_map(|line| line.strip_prefix("# ").map(str::len))	the chain trigger reads it instead, with a coarser split

Only the third and fourth rows can be wrong without the compiler saying so, which is where the care went: the rest are a compile error the reader would hit, so declining them costs a diagnostic rather than trust. A parallel adapter adds one more of the compiling kind, requiring what a lifted step produces to be Send where the folded form never moved it between threads.

Narrower than the planning file

The narrowings, each measured against this crate's own source, are recorded in the planning file's ## Status section rather than repeated here. The crate's own source obeys the rule with no #[allow] anywhere.

Its ## Deferred sections keep their text as the active spec: the unanchored chain, and arrays behind a purity test.

How it was checked

Beyond just all, two procedures ran against this branch.

Eight mutation passes. Every guard was removed in turn and the fixtures re-run, then again after each round of fixes added guards of its own. What that found, in order of how much it mattered: a correctness defect in always_evaluated; a defect in the emitted help; two unreachable guards removed; two dead table entries made live; and fixtures for the guards no test held. The last pass, over the sixteen guards the recombination and the widening added or changed, pinned fifteen first time and found one gap: the guard-and-value trigger's Iterator check, which every witness in the suite reached only through a family lookup that had already turned it away. rayon's filter_map is the witness that reaches it. Left untested on purpose, because no compiling program tells the mutant apart: steps' "the receiver is the chain" check, which the argument check and the occurs-once gate make redundant, and preceding's fallback for an operand its search cannot find, which every caller has already answered for.

Six rounds of correctness review, rounds 35 to 40 of this repository's loop: 44 findings, all valid, none rejected. Each was reproduced against the built driver, and every claim that a suggested rewrite does not compile was confirmed by compiling it. The largest classes were the lift target's reference depth and receiver, a missing liftability check in the guard-and-value trigger that the chain's has had all along, and documentation claims the code does not make. The last round could not break the round before it.

Every Bad fixture case has the Good one the help asks for, 92 pairs of them, so the advice is compiled rather than asserted. Two defects in the suggested forms came out of writing them: a map_or_else split that dropped the step it was meant to lift, and a try_for_each split that became a for_each and lost the Option<()> its folded form returns. Both were invisible to a suite that only asks where the rule fires. A generated probe outside the tree now runs each pair's two forms over the same inputs and compares, and asserts that the pair returns the same type.

The applied rewrite is run through the real fixer, over a fixture whose expected form is a file beside it, so the rewrite is pinned down to the brackets and nothing is reverted for failing to compile. That comparison is also the only place applicability is observable: a .stderr renders a suggestion whether or not cargo dylint --fix would apply it, so the ui sweep cannot tell MachineApplicable from Unspecified. Mutation-checked by making the comment guard always answer false, which the fixer run catches and the ui sweep cannot.

What it does not check is that the split answers what the folded form did. An oracle inside the fixture does catch that, and was measured at two extra cargo test invocations, 0.55s to 1.29s for this rule alone. One such fixture per rule with an autofix is what does not scale, so it is dropped pending a mechanism that would: one project holding every rule's inputs, fixed in one pass, with the result cached.

The chain trigger rewrites too, naming each step as the function it already is rather than inventing a binding: lines.for_each(|line| record(line.trim().len())) becomes lines.map(str::trim).map(str::len).for_each(record). Reusing the item's name was built first and rejected, since only the first step is handed the item and a |line| above a trim is bound to a length. A method step takes the path form only where the method's self type has the borrow depth and base type the receiver has, which keeps an item of String away from the str::len it reaches through a deref; such a step falls back to a closure over the item as the first step, and to a /* name */ placeholder above that, carried as Applicability::HasPlaceholders so it is shown and never applied.

That brings the ui suite to 86 suggestions, 15 of them holding a placeholder. Still advice: the guard-and-value trigger, a chain under an adapter taking the whole chain, and a piping method's leading step.

Changes outside the rule

• Shared helpers, all pub(crate): adapter_discipline, binding_uses, exclusive_captures, extra_reference and receiver_move, plus borrows and binds_mutably in common. Each is read by more than one trigger.
• ui/auxiliary/rayon_stub.rs and ui/auxiliary/pipe_trait_stub.rs stand in for crates this repository does not depend on; rayon, itertools and pipe-trait themselves were verified in scratch crates outside the tree. ui/auxiliary/proc_macro_synth_binding.rs gains derives that synthesise each trigger's shape.
• The crate's own source complies ahead of this PR, in KSXGitHub/perfectionist#506, so nothing here edits a file outside the rule to satisfy it. ui-toml/overly_long_method_chain/default/fixture.rs is the one exception that cannot go there, since its #[allow(perfectionist::splittable_adapter_closure)] names a lint that does not exist until this PR; its chains_in_closures case exists to show an inner chain of three.
• The fixtures are organised one per concern: what counts as a step, which adapters are in scope, what makes the lifted part compile, where the chain sits in the body, the families beyond Iterator, the extension traits, the conjunctions, which comparisons read as one test, the guard-and-value shapes, and one proc-macro regression file. // Bad: fires, // Good: is what the help asks for and stays silent, // Not flagged: is neither, and every Bad is followed by its Good.
• The refactor commit splitting four of the crate's own chained closures landed separately as KSXGitHub/perfectionist#504.

Verification

PERFECTIONIST_CARGO_LOCKED=true just all passes on the branch tip: fmt --check, build, doc, lint, test (269 unit tests plus 97 ui and every ui-toml fixture) and self-lint under -D warnings. Every commit was gated on the ui suite before it was made.

🤖 Generated with Claude Code

https://claude.ai/code/session_01A65ivJxFWzYSVxtGzcH2PX

---

Generated by Claude Code

[KSXGitHub]

Is this comment necessary?

[KSXGitHub]

Partly. One of its three sentences was a second copy of the body, and it is gone in ecc6942; the other two I'd keep.

The one that went:

The modules around at are asked for an import of it or a definition of it, innermost first.

That is hir_parent_iter and names_it, line for line — CLAUDE.md's rule about a passage that only restates the code beneath it. And "innermost first" was worse than redundant: the walk ends in .any(...), so the order it visits modules in cannot change the answer. A reader who believed the comment would go looking for a precedence the function does not have.

What stays, and why each earns it:

/// Whether `definition`'s own name resolves to it where `at` sits.

The function name says resolves_here; it does not say own name. That is the whole question — not whether some path reaches definition, but whether its last segment alone does, which is what decides between a point-free rewrite and an import offer.

/// A glob import is not followed, so a name only a glob brings in reads as
/// absent -- which costs a downgrade and an import offer the reader does not
/// need, where the opposite mistake would cost a rewrite that does not
/// compile.

The code can only show that globs are not followed. It cannot show that this was chosen, nor which way the asymmetry runs — a false "absent" costs a redundant use line in the suggestion, a false "present" costs a rewrite that does not compile. Without the paragraph the next reader cannot tell the omission from an oversight, and the ItemKind::Use arm in names_it is sitting right there to be "fixed".

---

Generated by Claude Code