fix(getter/ruby): subshell backtick delimiters are counted as operators

[dekobon]

Summary

Found reviewing the #1353 fix. Ruby's subshell delimiters are counted as
operators, the same fabrication #1312 removed for regex delimiters and
#1256 for Elixir — subshell was not in either issue's sweep.

tree-sitter-ruby aliases both ends of a `…` literal to the same
backtick token:

// grammar.js
subshell: $ => seq(
  alias($._subshell_start, '`'),
  optional($._literal_contents),
  alias($._string_end, '`'),
),

RubyCode::get_op_type (src/getter/ruby.rs) lists R::BQUOTE in the
operator arm for the def `(cmd) method-name marker, so every
subshell literal contributes two ` operator occurrences that are
nowhere in the source as operations.

Reproduction

u = `echo hi`

$ bca dump --no-config -p s.rb        # excerpt
╰─ {subshell:315} : `echo hi`
   ├─ {`:103} : `
   ├─ {string_content:138} : echo hi
   ╰─ {`:103} : `

$ bca ops --no-config -p s.rb
operators: =, `
operands:  `echo hi`, u

n1 2 / N1 3 for a line containing one operator. (Only the opening
delimiter shows in the deduplicated vocabulary, but N1 counts both —
get_operator_id_as_str folds the pair, exactly as it did for the regex
delimiters in #1312.)

Fix shape

The parent guard already sitting eleven lines above in the same match,
applied to the second delimiter family:

R::BQUOTE if ancestors.parent_has_kind(node, R::Subshell as u16) => HalsteadType::Unknown,

Parent, not ancestor — a backtick nested deeper (a def ` inside a
subshell's #{…} interpolation) must still count, which is the
distinction ruby_regex_guard_is_parent_scoped_not_ancestor_scoped
already pins for R::SLASH.

The subshell node itself is the operand (it reaches
string_operand_type in the string-like arm), so suppressing the
delimiters loses nothing.

Tests

Mirror the three regex tests directly:

• the counts for u = `echo hi` — n1 1 / N1 1, n2 2 / N2 2;
• def `(cmd) still bills a backtick operator, so the guard is
  parent-scoped and the method-name marker survives;
• a backtick inside a subshell interpolation still counts.

Sweep

#1314 enumerated eight interpolating languages for the opener question
and did not look at delimiter aliasing outside regex. Any grammar that
aliases a paired delimiter to a token the operator arm also lists is in
scope — bca ops on a one-literal file is the cheap probe, and a
fabricated operator shows up immediately as an n1 the source cannot
justify.

---

Resolution

Status: Fixed (pending merge)
Branch: fix/issue-1360
Commit: 9108f0ad — fix(getter/ruby): stop billing subshell backticks
(the hash may be rewritten when the branch is re-signed at merge)

Root cause: tree-sitter-ruby aliases both delimiters of every subshell
spelling — `…` and all six %x forms — to the same BQUOTE token,
which RubyCode::get_op_type lists in its operator arm for the def `
method-name marker, so each literal fabricated two ` operators.

Fix: suppress a BQUOTE whose parent is a subshell
(grammar-dispatch §5). Gated rather than deleted (§6) because the
method-name marker wraps its BQUOTE in a named operator node, and
parent- rather than ancestor-scoped so a backtick method inside a
subshell's interpolation still counts. Five regression tests, each
verified against four production mutants. Sweep found no sibling language
with this defect.

Two premises in the body above were corrected in the resolution comment:
the def ` marker is an operator-wrapped BQUOTE rather than a bare
one, and the backtick heredoc (<<~`CMD`) is not a subshell sibling
— it emits a single heredoc_beginning leaf with no BQUOTE.

[dekobon]

Fixed on fix/issue-1360 — commit 9108f0ad

Root cause

Confirmed as filed, with two corrections to the issue's supporting detail
(below). tree-sitter-ruby =0.23.1 aliases both delimiters of a
subshell literal to the same ` token. bca dump --no-config at the
pin shows all seven spellings emitting BQUOTE (kind 103) for the opener
and the closer:

source	opener kind	closer kind
`echo`	`:103	`:103
%x{echo}	`:103 (%x{)	`:103 (})
%x(echo) / %x[echo] / %x<echo>	`:103	`:103
%x|echo| / %x!echo!	`:103	`:103

RubyCode::get_op_type listed R::BQUOTE in its operator arm — needed
for the def ` method-name marker — so every subshell literal
fabricated two ` operator occurrences. u = `echo hi` reported
n1 2 / N1 3 for a line whose only operation is the assignment.

Same class as #1312 (Ruby regex / delimiters) and #1256 (Elixir);
subshell was in neither sweep.

Changes

src/getter/ruby.rs — one new arm, placed ahead of the operator arm
and immediately after the regex guard it mirrors:

R::BQUOTE if ancestors.parent_has_kind(node, R::Subshell as u16) => {
    HalsteadType::Unknown
}

Gated, not deleted (grammar-dispatch §6): a backtick is a legal Ruby
method name, and at this grammar def `(cmd) and s.`("ls")
wrap their BQUOTE in a named operator node, so the parent-scoped
guard leaves them alone. A blunt deletion of the kind would score
def `(cmd) at n1 3 / N1 3 instead of 4 / 4.

Parent, not ancestor, and here the difference is observable: a backtick
method inside a subshell's #{…} interpolation keeps operator as its
parent but gains the Subshell as an ancestor, so an ancestor scan would
swallow it.

src/metrics/halstead.rs — five regression tests.

.bca-baseline.toml, .rustfmt-bail-baseline.txt — both
refreshed in the same commit per AGENTS.md. The new arm moves
RubyCode::get_op_type's halstead.effort 114672 → 120866, and it is
the fourth stuck arm in a match that has been outside cargo fmt since
before this change (3 → 4).

Two corrections to the issue body

1. The def ` marker is not a bare BQUOTE. The issue reasons
   about BQUOTE being "in the operator arm for the def `(cmd)
   method-name marker" as though the guard needed care to avoid it. At
   the pin the marker is a BQUOTE wrapped in a named operator node
   (kind 300), so its parent is Operator and never Subshell — the
   parent guard preserves it structurally, not incidentally. This is what
   makes the §6 gate-don't-delete rule concrete here rather than
   hypothetical, and it is pinned by a positive-control test.

2. %x{…} and friends are covered, but not because they are a
   "heredoc-ish sibling". All six %x spellings route through the same
   subshell node with the same aliased BQUOTE delimiters, so one
   guard covers them. Two neighbouring constructs that look like they
   should be in scope are not: a backtick heredoc
   (x = <<~`CMD`) emits a single heredoc_beginning leaf with no
   BQUOTE at all, and :` is a simple_symbol. Neither is
   affected either way.

Languages affected

Ruby only. Halstead operator counts drop for Ruby code containing
subshell literals; n2/N2 are unchanged (the subshell node itself
remains the operand via string_operand_type, including the childless
`` spelling).

Sweep

The issue's "Sweep" section asked whether any other grammar aliases a
paired delimiter onto a token its operator arm also lists. Probed with
bca ops --no-config on one-literal files: PHP `ls`, Perl
`…`/qx{}/qw()/q()/qq()/m//, Elixir sigils, Bash, Tcl,
Python f/r/b/triple strings, JS + TS + TSX template literals and regexes,
Rust raw/byte strings, C# interpolated/verbatim/raw, Groovy /…/ and
$/…/$, Kotlin raw strings, Lua long brackets. No sibling found —
every one already reports only the real operators. Nothing is owed here.

Checker::is_string (src/checker/ruby.rs), src/alterator.rs and the
metric walkers all classify the Subshell node, whose treatment is
unchanged, so grammar-dispatch §7 parity holds. No Subshell2 or
Operator2 alias exists in the enum (§1).

Tests added (src/metrics/halstead.rs)

test	claim
ruby_subshell_delimiters_are_not_operators	x = `echo hi` → n1 1 / N1 1, n2 2 / N2 2 (was n1 2 / N1 3)
ruby_subshell_delimiter_choice_is_invariant	all seven spellings plus the empty `` score identically
ruby_backtick_method_name_survives_the_subshell_guard	def `(cmd) still bills a backtick operator — n1 4 / N1 4
ruby_subshell_guard_is_parent_scoped_not_ancestor_scoped	n = `a#{def `(c); c; end}b#{s.`("x")}` → n1 7 / N1 10
ruby_subshell_start_alias_never_reaches_kind_id	BQUOTE2 (the collapsed _subshell_start alias) stays unreachable

Verified by perturbation, not by passing. Four mutants of the
production line, each run against the whole set with --no-fail-fast:

mutant	tests that fail
guard removed (pre-fix classification)	delimiters_are_not_operators (n1 2≠1), delimiter_choice_is_invariant ([2,3,2,2]≠[1,1,2,2]), parent_scoped (N1 12≠10)
ancestor scan instead of parent check	parent_scoped only (n1 6≠7, N1 8≠10)
BQUOTE deleted from the operator arm instead of gated	backtick_method_name_survives (n1 3≠4), parent_scoped
Subshell wrapper suppressed as well as its delimiters	delimiters_are_not_operators (n2 1≠2), delimiter_choice_is_invariant ([1,1,1,1])

Every assertion family — n1, N1, n2, N2 — is the first failure
under at least one mutant, so none is decoration. All expected values are
literal integers hand-derived token by token from bca dump, never
re-derived from the live parse tree.

Validation

• make pre-commit → BCA_GATE: pass (gate=pre-commit) (re-run after
  the review-driven comment fixes).
• cargo test --workspace --all-features clean; no .snap.new under
  tests/repositories/big-code-analysis-output/. The integration corpora
  contain zero .rb files, so no integration snapshot moves and no
  submodule bump is owed.
• Coverage (cargo llvm-cov nextest -p big-code-analysis --all-features,
  package-scoped: 82,549 regions, 98.04%): src/getter/ruby.rs 43
  regions / 1 missed → 42 covered; src/metrics/halstead.rs 4,856
  regions / 18 missed → 4,838 covered. 100% of changed regions are
  covered — the one missed region in getter/ruby.rs is line 17,
  get_space_kind's wildcard, pre-existing and untouched here; none of
  halstead.rs's missed lines fall in the new 6809–6960 hunk.

Review

An independent fresh-context review re-derived every grammar claim
against the pinned grammar and returned no bugs, no performance and no
security findings. Three comment-accuracy findings were remediated
before commit — one of them the exact borrowed-rationale failure mode the
review was asked to hunt: the BQUOTE2 drift marker claimed a bump would
"silently reintroduce the fabricated operator", when in fact BQUOTE2 is
in no dispatch arm, so an emitted BQUOTE2 falls to the wildcard and the
opener would go uncounted instead. The comment now states the real
exposure (a def ` marker spelled BQUOTE2 would stop counting).