fix(lint): stop equality-arity reporting eql type specifiers

[takeokunn]

Follows #119 and #120. CLHS 4.2.3 makes (eql object) a compound type specifier — so in a type position one argument is the only legal spelling, not a defect. equality-arity reported it anyway, at Severity::Error.

The measured rate is worse than estimated

A seeded random sample of 120 of the 1,307 findings #120 left behind, each read with source context:

	count
standard-CL type positions	71
SBCL-internal type positions	25
non-type positions (case keys, trivia patterns, multiple-value-bind)	24
true positives	0

Essentially all 1,307 are false positives (95% CI ≥ 97.6%) — against my ~74% estimate. Unsurprising once stated: the corpus is shipped, compiling code, and a genuine one-argument (eql x) in call position is a compile-time error.

Why this could not be another guard

The quote guard was a local predicate. This is not: the same text is a type in one place and a call in another — (eql 7) as a defmethod parameter versus as a progn body form — so the rule must know the node's role, which lives in its ancestor.

type_table() cannot answer it. It exposes expression_type and binding_type, both asking what type an expression has. (eql 7) in a specializer has no type — it is one. And infer_view (typing/service/inference.rs:104) returns Type::Unknown for anything is_opaque_to_evaluation, so a specializer is never visited. lint-type-declaration has no type-position finder either: its type_excludes classifies a spec it has already been handed.

So: a structural ancestor walk, mirroring the existing quote_state_at root descent in the same file.

The contexts were measured, not assumed

A probe crate path-depending on the repo's own paredit-core-syntax/lint-engine ran the real dispatch with only this rule enabled, joined each finding to its ancestor chain by byte span, climbed past compound-specifier combinators, and bucketed the nearest non-combinator ancestor. That distribution produced the set:

context	standard CL?	implemented
typecase/etypecase/ctypecase clause head	yes	✅
defmethod / defgeneric :method EQL specializer	yes	✅
declare/declaim/proclaim (type …)/(ftype …)	yes	✅
the, check-type	yes	✅
slot :type (defclass/defstruct)	yes	✅
defknown, deftransform, define-vop, specifier-type, …	no — SBCL internals	❌ deliberate

Two shapes on the original list are traps and stay reported. typep, subtypep and coerce are functions — their type argument is evaluated, so (typep x (eql 5)) really is a one-argument call; only the quoted '(eql 5) spelling is a specifier, which is #120's job. Anchoring them dropped the overlap with #120 from 540 to 3. There are now tests asserting all three stay reported. satisfies and member are not descent paths either.

SBCL internals excluded on principle: teaching a general CL linter one implementation's compiler macros would silence any user macro sharing a name. That leaves 384 findings unfixed and reported rather than hidden.

Mutation testing found a bug in the draft

Dropping a shape check revealed that (defmethod g (a &key (k (eql y))) …) has the identical (name form) shape as a specializer — but that second element is a default value form: live code, and a genuine one-argument call. Only required parameters may be specialized, so the walk now requires no &-keyword before the parameter. Corpus counts were unchanged, making it pure false-negative prevention.

13/13 mutants killed, each verified changed by byte comparison and git diff --no-ext-diff before running. The harness itself had a flaw caught in passing: matching "error: " on stderr misread cargo's error: test failed and reported 12 false "broken" mutations; tightened to error[E/could not compile.

Differential

	total	hard-quoted	post-#120 remainder
before	1,981	674	1,307
after	1,302	671	631

679 removed, 0 added — all eql at exactly one argument; no other operator or arity moved. Only 3 overlap #120, so the net effect on the 1,307 is 676 (−51.7%).

Removals by anchor: 318 specializer, 271 typecase-family, 41 declare/declaim, 23 slot :type, 16 the, 10 check-type.

Controls

Still fires on: (eq x), (eql x), (eql), (eql a b c), (equal a), (equalp a b c d) — as progn body forms, inside defun, and inside a quasiquote template; on (typep x (eql y))/subtypep/coerce; on (or (eql x) y) under a bare or; on a case clause head; on a typecase keyform; on the's value form; and on the specializer shape under a non-method definer and in a method body.

Silent on: defmethod specializers (including :around, (setf g), :method, shouted, cl:-qualified, quasiquoted templates), typecase-family clause heads including nested (cons (eql …))/(or …)/(and … (not …)), declare/declaim types, the, check-type, slot :type.

Cost

Whole corpus 4.749 s vs 4.493 s (+5.7%, ~0.13 ms per finding adjudicated). On the 5,097 zero-finding files: 0.767 s vs 0.756 s — noise. The walk sits behind argument_count == 1 && operator == "eql", both of which require a finding to exist, so clean code never reaches root_view().

Still unfixed, worth separate PRs

631 remain and are still ~100% false — but for reasons outside this scope: 384 SBCL-internal (recommend leaving), 136 case/ecase clause keys ((case kind (eql <body>)) is a key designator, never a call), 49 trivia patterns, 33 multiple-value-bind variable lists.

Given the measured rate, Severity::Error on this rule is hard to justify until at least the case-key class is fixed.

No golden or pinned count moved. cargo build --workspace / fmt --check / clippy --all-targets --all-features -D warnings / test --workspace all exit 0.