fix(getter/ruby): complex and rational literals double-count their inner numeral

[dekobon]

Summary

Found reviewing the #1353 fix; the same wrapper/leaf double count one arm
below the one that issue names (.claude/rules/grammar-dispatch.md §5).

RubyCode::get_op_type (src/getter/ruby.rs) lists Integer, Float,
Complex and Rational side by side in the plain operand arm. But
tree-sitter-ruby nests them:

// grammar.js
complex:  $ => seq(choice($.integer, $.float, $.rational), /i/),
rational: $ => seq(choice($.integer, $.float), 'r'),

so the wrapper and the numeral it wraps are both billed.

Reproduction

a = 1r
b = 2i
c = 3ri
d = 4

$ bca dump --no-config -p n.rb        # excerpt
╰─ {rational:308} : 1r
   ╰─ {integer:108} : 1
╰─ {complex:307} : 2i
   ╰─ {integer:108} : 2
╰─ {complex:307} : 3ri
   ╰─ {rational:308} : 3
      ╰─ {integer:108} : 3
╰─ {integer:108} : 4

$ bca ops --no-config -p n.rb
operands: 1, 1r, 2, 2i, 3, 3ri, 4, a, b, c, d

Four literals and four names is eight operands; bca metrics reports
n2 11 / N2 12. 3ri is billed three times, once per level of the nest.

Fix shape

Not a deletion: both wrappers are always non-childless
(seq(choice(...), …) makes the inner numeral required), so the leaf is
never a literal's sole carrier and dropping Complex / Rational from
the operand arm is safe and loses nothing — the analogue of #1351's Bash
command_name rather than #1353's gated %w[].

The design fork is which node keeps the classification. Keeping the leaf
matches how #1263 / #1293 / #1352 settled qualified names — bill the
component, not the whole span — but it silently drops the r / i
suffix from the operand text, so 1 and 1r would share one vocabulary
entry. Keeping the wrapper preserves the distinction. Decide with
bca dump before writing the arm, and check whether a bare 1r at
top level (no enclosing complex) still yields a rational; if the
grammar ever emits a suffix-only spelling with no inner numeral, the
answer flips to a gate.

Tests

Per-line N2 assertions for 1r, 2i, 3ri and a plain 4, plus
assert_ops_operands pinning the operand text so a returning wrapper
shows up by name. Test-via-revert per .claude/rules/testing.md;
3ri is the row that discriminates a one-level fix from a complete one.

Sweep

Only Ruby was checked. Any language whose grammar wraps a numeric
literal in a suffix/prefix node is a candidate — worth a pass over
src/getter/*.rs for Complex / Imaginary / Rational / Long /
Unsigned style wrappers before closing this.

Resolution

Status: Fixed (pending merge) — branch fix/issue-1359, commit
15ac604d (the hash may be rewritten when the branch is re-signed at
merge).

RubyCode::get_op_type billed every level of a suffixed numeric
literal's nest because Integer, Float, Complex and Rational sat
side by side in one plain operand arm; a numeral whose parent is a
complex or a rational is now suppressed, leaving the wrapper — whose
span carries the r / i suffix — as the single operand.

One premise in the body above needed correcting: the grammar excerpt is
from upstream HEAD, not the pinned =0.23.1. See the comment below.

[dekobon]

Fixed on fix/issue-1359 in 15ac604d (hash may be rewritten when the
branch is re-signed at merge).

Root cause

RubyCode::get_op_type listed Integer, Float, Complex and
Rational side by side in the plain operand arm, so each level of a
suffixed numeric literal's nest was billed as its own Halstead operand.
The reproduction confirms exactly as filed: a = 1r; b = 2i; c = 3ri; d = 4 reported n2 11 / N2 12 for eight operands, and now reports 8 / 8.

Premises verified, and one corrected

• The arm still listed all four kinds side by side. Confirmed; nothing
  since fix(getter/ruby): chained_string and %w/%i arrays double-count their elements #1353 had touched it.

• The grammar excerpt in the body is upstream HEAD, not the pinned
  tree-sitter-ruby =0.23.1. The pin actually has

  _int_or_float: $ => choice($.integer, $.float),
  complex: $ => choice(
    seq($._int_or_float, token.immediate('i')),
    seq(alias($._int_or_float, $.rational), token.immediate('ri')),
  ),
  rational: $ => seq($._int_or_float, token.immediate('r')),

  complex does not admit a real rational child — the ri form
  aliases _int_or_float to rational. The observable nesting is the
  same three levels the body describes, so the conclusion holds, but the
  middle node's span is bare (3, no r) and it needs no new alias
  variant in the enum. bca dump at the pin confirms it.

• The 3ri three-level nest is real, and the counts follow: pre-fix
  c = 3ri alone scored n2 3 / N2 4, not 3 / 3.

• "required": true on both wrappers' lone numeral child: confirmed in
  the pinned node-types.json, so deleting the kinds would have been
  safe too. The gate was chosen for a different reason (below).

• No numeric-suffix alias variants (Integer2, Complex2, …) exist for
  any of the four kinds. Ruby::IntOrFloat (_int_or_float, 306) is a
  hidden rule the parser never emits; that is now pinned by an
  !ast_has_kind_id drift marker per grammar-dispatch §2.

The design fork the body raises

Kept the wrapper, gated the leaf — the opposite of what #1351 and
#1358 did for their Bash wrappers.

§6's keeper rule ("the node present for every spelling") would pick the
leaf, but that rule exists to stop a childless variant scoring zero,
and neither choice can do that here: both wrappers' numeral child is
required, and an unsuffixed 4 carries no wrapper at all. With the
hazard absent the tiebreak is operand identity. 1, 1r, 1i and
1ri are four distinct Ruby constants and only the wrapper's span
carries the suffix saying which — billing the leaf files all four under
the operand text 1, giving n2 5 / N2 8 for eight operands (measured,
not derived). Every other language here spells a numeric suffix inside a
single token (1u32, 1L, 1j), so wrapper-keeping is also what makes
Ruby agree with its siblings. It is the same resolution the Nil /
Nil2 pair fifteen lines below already takes.

Changes

File	Change
src/getter/ruby.rs	New guarded arm: Integer | Float | Rational → Unknown when the parent is a Complex or Rational. Parent, not ancestor, per §5 — though the comment records that the two are indistinguishable at this grammar, since complex and rational admit numeral children only.
src/metrics/halstead.rs	Two regression tests.
.bca-baseline.toml	RubyCode::get_op_type halstead.effort 97 661 → 114 672 (the new arm), plus three unrelated decreases the regenerate picked up from earlier commits on the branch.

Languages affected: Ruby only.

Tests

ruby_suffixed_numeric_literals_bill_one_operand_1359 — ten rows,
ordered by nesting depth, each asserting [n1, N1, n2, N2] and the
operand text: 1r / 2i (two levels), 3ri (three), the float-leaf
forms 1.5r / 2.5i / 1.5ri, a plain 4 (no wrapper, must not
move), "#{4r}" and -3r (wrapper in a non-assignment position), and
1r + 1r (the one row where N2 != n2, so the N2 column is
load-bearing rather than tracking n2).

ruby_numeric_suffixes_stay_distinct_operands_1359 — the assertion that
discriminates wrapper-keeping from leaf-keeping.

Verified by perturbing production three ways, each failing both tests:
the pre-fix arm; a one-level fix guarding only Integer | Float (fails
first at c = 3ri with n2 3 / N2 3, passing 1r and 2i — which is
why the ri rows exist); and the leaf-keeping alternative. A further
nine perturbations of the tests' own expected values each failed the
named test, so no assertion is dead.

Coverage

100% of changed regions. src/getter/ruby.rs is 37 regions / 1 missed
(97.30%); the single miss is line 17, the _ => SpaceKind::Unknown arm
of get_space_kind, pre-existing and outside the hunk, which the diff
does not touch. src/metrics/halstead.rs 4767 / 18 (99.62%). Package
total 98.04% region (--package big-code-analysis --all-features).

make pre-commit reports BCA_GATE: pass; 5552 workspace tests pass.
No Ruby sources exist in the integration corpora, so no snapshots moved
and the big-code-analysis-output submodule pointer is unchanged.

Sweep

Swept every grammar in the workspace for a nested numeric-literal
wrapper by scanning each node-types.json for a numeric-named type with
named children. Four candidates outside Ruby, all clean: Rust
negative_literal, C++/mozcpp user_defined_literal (1_km over a
number_literal — the identical shape) and Python complex_pattern are
none of them classified by their getter, so the leaf already carries the
count exactly once. Bash number is classified and its children are
optional, but every spelling probed emits it as a leaf, with expansions
as siblings rather than children.

Ruby has no other numeric wrapper: complex and rational are the only
named kinds in that operand arm with named children at all.

One genuine sibling defect fell out of the §7 cross-walk and is filed
separately as #1379 — ruby_bool_terminal_kinds! names Integer but
not Float / Complex / Rational, so a && 1.0 scores
abc.conditions 1 where a && 1 scores 2. Elixir has the same gap for
Float; Python already handles both. Out of scope here (ABC does not
consult get_op_type).