fix(csharp): a `when` guard on a switch arm is a branch neither metric counts

[dekobon]

Summary

A when guard on a C# switch arm is a real branch — the pattern can match
while the guard fails — and neither metric models it. C# cyclomatic has
no when_clause arm, and C# ABC has no guard rule. ABC nonetheless appears
to count some guards, because its token arms fire on whatever operator
happens to sit inside one. The result is that the score depends on how the
guard is spelled rather than on what it does.

Found while fixing #1383,
which deliberately left the guard alone.

Measured

At HEAD of fix/batch-2026-09-10 (after #1383):

class A {
    static bool IsEven(int x) { return true; }
    int tok(int x) => x switch { > 0 when x % 2 == 0 => 1, > 0 => 2, _ => 3 };
    int cmp(int x) => x switch { > 0 when x > 2      => 1, > 0 => 2, _ => 3 };
    int call(int x) => x switch { > 0 when IsEven(x) => 1, > 0 => 2, _ => 3 };
}

guard	abc.conditions	cyclomatic()	cyclomatic() - 1
when x % 2 == 0	3	3	2
when x > 2	3	3	2
when IsEven(x)	2	3	2

Three semantically equivalent guards, two different ABC scores. The ==
and > are counted by csharp_count_token_condition's EQEQ | BANGEQ and
GT | LT arms respectively; IsEven(x) contains no such token, so it
contributes nothing.

Cyclomatic is uniform at 3 across all three — it counts the two non-discard
arms and the base, and never the guard.

Two defects, one fixture

1. Cyclomatic under-counts. A guarded arm has two exits (pattern fails;
   pattern matches and guard fails) but contributes one decision. Compare
   Rust and Python, which do count a match guard — measured as part of
   fix(abc/csharp): relational pattern operator double-counts against its arm #1383's sibling sweep, match n { x if x > 5 => 1, _ => 0 } scores
   cyclomatic 3, and C#'s equivalent scores 2. So C# is the outlier among
   the languages here, not the convention.
2. ABC is spelling-dependent. Whatever is decided for (1), ABC should
   score a guard by what it is, not by whether its body happens to contain a
   token an unrelated arm matches.

Where

• src/metrics/cyclomatic/csharp.rs — counts SwitchExpressionArm (and the
  statement switch's Case), with no when_clause arm.
• src/metrics/abc/csharp.rs, csharp_count_token_condition — the token
  arms that incidentally fire inside a guard.

csharp_switch_arm_guard_operator_still_counts in src/metrics/abc.rs
pins the current behaviour and cross-references this issue, so a fix here
must update that test deliberately rather than discovering it.

Note for whoever takes this

.claude/rules/grammar-dispatch.md §8 asks for
abc.conditions == cyclomatic() - 1 per space, and the temptation will be
to reach it by suppressing ABC's guard token. That is the wrong direction:
it would make tok and cmp agree with a cyclomatic count that is itself
too low. Fix cyclomatic first, then re-derive what ABC should say.

Both changes move published metrics for C#, so each wants a corpus pass.
Be aware the DeepSpeech corpus contains no switch expressions at all
(established in #1383), so it cannot measure either.

---

Resolution

Status: Fixed (pending merge)
Commit: eb4468c (+ d08eb8e) on branch fix/batch-2026-09-13

[dekobon]

Fix Summary

Scope widened on measurement: the issue names when_clause only. C#
spells the catch (E e) when (…) filter as a different node,
catch_filter_clause (331), with the identical defect — measured before the
fix: operator filter 3 conditions, call filter 2, no filter 2, all at
cyclomatic 2. Both are fixed.

Cyclomatic first, as the issue insists. WhenClause | CatchFilterClause
added to the both-tier arm. Rust already counts a match guard, so C# was the
outlier.

Then ABC, modelled as a condition slot rather than by suppressing the
operator — suppression would have reached agreement one count below C#'s own
decision count. The existing FIXME(#1422) predicted exactly this shape ("a
guard modelled as a condition slot would score the is test instead, taking
this to 2"), and that is what it now does.

Two grammar details the slot turns on, both found by bca dump rather
than assumed:

• The clause nodes, not the when keyword they share. When (119) is also
  a _reserved_identifier, so int when = 1; return when + when; emits the
  token three times under identifier — a token gate would have scored 3
  spurious decisions in that one function.
• Every named child, not the first. tree-sitter extras are named nodes, so
  when /*c*/ g hands a comment to a first-child read and silently restores
  the spelling-dependence this fix removes. Caught by the independent review
  before it shipped; csharp_guard_keeps_its_condition_across_a_comment pins
  it and reverting that one line is its only failure.

A follow-up commit was needed (d08eb8e9). The whole-branch review found
the fix's own claim that a guard "scores one however it is spelled" was still
false for when x is int: csharp_bool_terminal_kinds!() listed
IsPatternExpression (392) but not IsExpression (391), which are distinct
kinds — the grammar emits the second only once a pattern is involved. Measured
when x is int 1 against when IsEven(x) 2. Fixed, with a regression test.

Snapshots: one, csharp/control_flow.cs — Bucket (switch guard)
cyclomatic 6→7, SafeDivide (catch filter) 3→4, rippling into mi and wmc.
ABC does not move there, because both corpus guards are operator-shaped, which
is precisely the asymmetry this fixes and why the defect survived the corpus.
Submodule cf1ef381.

Siblings not fixed here, filed as #1454: Java is missing both halves
(Java::Guard appears nowhere under src/metrics/), Rust and Python have the
ABC half. Rust and Python also under-count a bare guard, which is the
opposite direction.

[dekobon]

Follow-up: doc scope

The metrics.md row and the CHANGELOG entry this fix added state the guard
rule without scoping it to C#. Java 21 pattern guards, Rust, Python, Elixir
and Ruby do not implement it — measured in #1454 — so a reader of either
text currently sees a rule their language does not follow.

Either the siblings land (#1454) or both texts need a scope qualifier.
Recorded here so the choice is deliberate rather than inherited.