fix(ingestion): fully-qualified nested-type identity for C++/Ruby — structure (#1978) + resolution (#1982)

[magyargergo]

Scope: this branch now carries both halves of the #1978 fully-qualified nested-type work — the structure phase (#1978, original) and the resolution phase (#1982, the follow-up the earlier "Deferred" section promised) — plus a merge of main. Both halves are verified together; sections below.

Problem

Nested types that share a tail name within one file silently collapsed onto a single graph node keyed by the simple tail (e.g. both Outer::Inner and Other::Inner → one Struct:file:Inner node). Members cross-wired onto that one owner, and on the resolution side same-tail heritage (EXTENDS/IMPLEMENTS) and mixin / attr_accessor owners bound to the wrong sibling — silent wrong edges (0 dangling, so undetected by findDanglingEdges).

struct Outer { struct Inner { void from_outer(); int outer_field; }; };
struct Other { struct Inner { void from_other(); }; };
struct DerivedB : Other::Inner {};   // EXTENDS mis-resolved to Outer.Inner (wrong sibling)

---

Part 1 — Structure phase (#1978)

Key class-like type nodes (Class / Struct / Interface / Enum / Record) by their normalized fully-qualified path (Struct:file:Outer.Inner) instead of the simple tail, so same-tail nested types stay distinct. Gated per-language by a qualifiedNodeId config flag — default false, so every other language is byte-identical (verified empirically). Enabled for C++ and Ruby.

• class-types.ts / class-extractors/generic.ts — qualifiedNodeId on ClassExtractor + ClassExtractionConfig (?? false).
• utils/ast-helpers.ts — findEnclosingClassInfo gains an optional getQualifiedOwnerName hook + EnclosingClassInfo.qualifiedClassId. Member-owner edges resolve to the qualified class node id, derived from the same extractQualifiedName the node id uses → owner id == node id by construction.
• parsing-processor.ts (sequential) + workers/parse-worker.ts (worker) — flag-gated qualified node id + owner edges on both parse paths, incl. the worker routed-property block.
• call-processor.ts — the same qualifier in the sequential routed-property pre-pass, kept in lockstep with the worker kind === 'properties' block.
• configs/c-cpp.ts, configs/ruby.ts — qualifiedNodeId: true.

Method/Property node ids stay simple-qualified (className.member); only type nodes get the fully-qualified id.

---

Part 2 — Resolution phase (#1982)

Registry-primary resolution still keyed same-tail nested types by their simple tail, so struct DerivedB : Other::Inner mis-resolved its EXTENDS to Outer.Inner (first-wins on the bare tail in resolveInheritanceBaseInScope), and Ruby's emitRubyMixinEdges cross-wired same-tail mixin / attr_accessor owners (last-wins) — exactly the items Part 1 deferred. Characterization confirmed these were wrong edges, not refusals.

• Shared normalizer — normalizeQualifiedName / splitQualifiedName extracted to utils/qualified-name.ts so the structure phase, the resolution inheritance path, and per-language captures all key against one ::/\→. normalizer (NOT the heritage simplifyRawName, which collapses to the tail and would guarantee a lookup miss).
• C++ heritage — the inheritance capture preserves the qualifier (@reference.qualified-name, additive, template-stripped: ns::Base<T> → ns::Base; registered as a sub-tag so it can't shadow the @reference.inherits anchor). resolveInheritanceBaseInScope resolves it against the full-path QualifiedNameIndex qualified-first — with progressive-prefix lookup for relative bases (Outer::Inner written inside namespace NS → NS.Outer.Inner) and refuse-on-tie — falling through to the existing simple-tail walk on miss. The index already carries the distinct Outer.Inner / Other.Inner keys from Part 1, so no type-registry change is needed.
• Ruby emit map — emitRubyMixinEdges keys owners by the full def.qualifiedName, and the __heritage__ / __property__ markers carry the full enclosing-scope owner (buildEnclosingQualifiedName, handling the compact class Outer::Inner form). This closes the deferred same-tail routed-property / mixin owner item — on both the sequential and worker paths (markers survive worker serialization).

Additive + gated: the qualifier sidecar is emitted only by C++; the qualified-first branch is gated on a new optional ReferenceSite.rawQualifiedName (set only by C++), so non-C++ inheritance resolution is byte-identical. New resolution-side assertions are registry-primary-only (legacy leg skips them via helpers.ts).

---

Still deferred (separate follow-up issues)

• Global simpleKey refuse-on-ambiguity gate — a defense-in-depth net (a Map-shape change with global blast radius); not needed for acceptance, since the qualified path already resolves the same-tail case correctly.
• Dart — has no qualifiedNodeId flag yet, so the qualifier threading is inert for it; belongs to the C++/Rust scoped-declaration method ownership + pre-existing tail-keyed nested-type node collision (#1975 / #1977 follow-up) #1978 language fan-out.
• Rust inherent-impl (impl_item) same-tail ownership — still describe.skip (reason inline); the impl target needs a mod-scope walk + registry-primary bridge match.

---

Testing

• New same-tail collision fixtures (C++ / Ruby / Rust) + #1978 resolver tests asserting positive owner identity (R7) (resolved owner / edge endpoint by node id, not merely dangle-free).
• #1982 resolver tests: C++ same-tail EXTENDS (incl. qualified-cross-scope + cpp-diamond single-candidate regression guard); Ruby same-tail attr_accessor + mixin owner identity — each with a worker-path parity block so the qualified logic is exercised on the production pool, not just sequential.
• Capture goldens regenerated localized (only the one edited Ruby fixture drifts; all others byte-identical); bench/scope-capture fingerprints rebaselined for cpp + ruby (additive) with provenance notes — 14/14 PASS.

Verified green: C++ + Ruby resolver suites on both parity legs (registry-primary + legacy) + the worker pool; a cross-language regression triangulation (go / java / csharp, 542 tests — the qualified-first branch is gated on rawQualifiedName, set only by C++); all capture goldens; tsc, eslint (0 errors), prettier, npm run build.

Both halves were shaped by an adversarial multi-agent verification pass — which (Part 1) surfaced the call-processor lockstep gap, missing worker coverage, and a non-discriminating #1975 assertion, and (Part 2) twice re-targeted the resolution-side plan onto the actual registry-primary path (preEmitInheritanceEdges → resolveInheritanceBaseInScope, not the legacy buildHeritageMap) before any code landed.

---

Merge of main

This branch also merges origin/main (brings #1934 rust F71 union / F72 macro, rust-coverage #1974, Go interface-impl / type-binding work). Conflicts resolved: rust.test.ts (kept both the deferred-Rust describe.skip block and main's F71/F72 blocks) and the baselines.json rust fingerprint (recomputed for the merged corpus — main's rust fixtures ∪ #1981's rust-nested-tail-collision, 126→127 fixtures). Post-merge re-verified: tsc, bench 14/14, rust 169-pass, cpp 278 + ruby 142 + 7 goldens all green.

Risk

Contained to the ingestion structure + scope-resolution phases, gated per-language. findEnclosingClassInfo and resolveInheritanceBaseInScope gained optional parameters (backward-compatible; all existing call sites unchanged). Node-id and resolution changes apply only to C++/Ruby nested types — validated on both legs and the worker path.

🤖 Generated with Claude Code

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
gitnexus	Ready	Preview, Comment	Jun 3, 2026 1:37pm

[magyargergo]

Deferred resolution-side items (Ruby same-tail routed-properties/mixins via emitRubyMixinEdges, and Rust inherent-impl ownership) are tracked in #1982.

[github-actions]

✨ PR Autofix

Found fixable formatting / unused-import issues across 42 changed lines. Comment /autofix on this PR to apply them, or run npm run lint:fix && npm run format locally.

{"schema":"gitnexus.pr-autofix/v2","state":"fixes-available","pr_number":1981,"changed_lines":42,"head_sha":"ddc31ba72ef4b287023a0c2cd59b63763324e950","run_id":"26860586192","apply_command":"/autofix"}

[github-actions]

CI Report

✅ All checks passed

Pipeline Status

Stage	Status	Details
✅ Typecheck	success	tsc --noEmit
✅ Tests	success	unit tests, 3 platforms
✅ E2E	success	gitnexus-web changes only

Test Results

Tests	Passed	Failed	Skipped	Duration
11014	10999	0	15	686s

✅ All 10999 tests passed

15 test(s) skipped — expand for details

• COBOL pipeline benchmark > scales with file count
• C++ ADL emit benchmark > emit phase scales sub-quadratically with co-scaled files and sites
• C++ pipeline benchmark > scales with file count
• C# pipeline benchmark > scales with file count — namespaces spread across the solution
• C# pipeline benchmark > scales with file count — all types in one (global) namespace bucket
• C# pipeline benchmark > scales with file count — all types in one (named) namespace bucket
• Go pipeline benchmark > scales with file count (workers enabled)
• Go pipeline benchmark — worker pool (issue Worker idle timeout kills long Go scope extraction and surfaces as Napi::Error during analyze #1848) > does not quarantine the large generated Go file on sub-batch idle timeout
• Go structural interface detection benchmark > scales linearly with interface × struct count
• Go structural interface detection split-phase benchmark > separates index-build and detection time
• PHP pipeline benchmark > scales with file count (workers enabled)
• Ruby pipeline benchmark > scales with file count (workers enabled)
• Rust pipeline benchmark > scales with file count (workers enabled)
• run.cjs direct-exec entrypoint (fix(cli): steer docs, skills, and hooks through a CLI-neutral project-local runner (#1939) #1945) > resolves a .cmd shim via the Windows shell branch, passing args and exit code
• buildTypeEnv > known limitations (documented skip tests) > Ruby block parameter: users.each { |user| } — closure param inference, different feature

Code Coverage

Tests

Metric	Coverage	Covered	Base	Delta	Status
Statements	80.37%	38443/47830	79.84%	📈 +0.5	🟢 ████████████████░░░░
Branches	68.94%	24470/35492	68.5%	📈 +0.4	🟢 █████████████░░░░░░░
Functions	85.53%	4003/4680	84.94%	📈 +0.6	🟢 █████████████████░░░
Lines	83.96%	34578/41181	83.36%	📈 +0.6	🟢 ████████████████░░░░

---

_{📋 View full run · Generated by CI}

[magyargergo]

Tri-review — qualify nested-type node identity for C++/Ruby (#1978)

Methods & engine breakdown (read first). 7 Claude reviewer lanes ran (correctness, adversarial, maintainability, performance, testing + 2 GitNexus lanes that ended mid-investigation — their domains were covered by the others). Codex (gpt-5.5, xhigh) ran but stalled before emitting retrievable structured findings — only truncated message previews were captured; I extracted one lead from it (heritage resolution of nested bases) and reproduced it myself. So weight this as a Claude-method review (one engine, several personas) with a single coordinator-verified Codex lead — not three independent confirmations. Persona agreement is "consistent," not independent.

• Final verdict: production-ready with minor follow-ups.
• Branch hygiene: clean feature/fix PR (behind main but mergeable; no unrelated churn).
• Merge state: checks passing (core) — the first push failed quality/format + the scope-capture golden + the fingerprint gate (all from the new fixtures); fixed in e2641628 (prettier; regenerated ruby/rust goldens; rebaselined cpp/ruby/rust fingerprints — golden regen proven additive-only) and now green: format, lint, coverage, benchmarks all pass. scope-resolution parity still running (long job), verified locally on both legs (#1978 tests are registry-primary-only on the legacy leg via helpers.ts).

What's solid (credit)

The central owner-id == node-id invariant holds across plain / namespaced / templated / explicitly-specialized C++ and nested / compact-:: / reopened-module / singleton Ruby — correctness and adversarial probed it hard and could not break it. The constraintsTag asymmetry between parsing-processor and parse-worker is a non-issue for class-like ids (it only applies to Method/Function). The hoisted qualifiedTypeName is pure; the qualified !== simple guard is sound; normalizeQualifiedName only unifies genuinely-same types (Ruby reopening, C++ out-of-line + forward-decl). Flag-OFF is byte-identical; the legacy-leg exclusion strings are exact.

Headline — [P1 · reproduced] heritage mis-resolution for same-tail nested bases (registry-primary)

Inlined on c-cpp.ts. A class inheriting from a same-tail nested type mis-resolves its EXTENDS/IMPLEMENTS edge to the wrong sibling (the heritage builder resolves the base by simple tail name via the node-lookup simpleKey, first-wins; #1978 split the two Inner nodes). 0 dangling edges, so findDanglingEdges cannot catch it. This is the same resolution-side simpleKey class already deferred to #1982 — recommend folding it there (one qualified-owner/simpleKey fix covers heritage + properties + members uniformly) and documenting same-tail-nested-base heritage as a known limitation. Narrow trigger, but it silently corrupts impact-analysis on the orphaned type, and no test catches it.

Secondary

• [P2 · reproduced] union- and anonymous-namespace-nested same-tail C++ types still merge (inlined on c-cpp.ts): ancestorScopeNodeTypes omits 'union_specifier'; anon namespaces add no scope segment. Same bug class, not in #1982.
• [P2 · code-read] buildQualifiedName hot-path cost: the new owner hook calls it per member (was once per class), and it walks to the tree root + scans top-level children every call with no per-file fileScopeSegments memo. Gated to C++/Ruby, est. <5%, but this repo has an O(n²) scope-capture history — memoize fileScopeSegments per file and hoist the per-iteration closure out of the symbol loop. (generic.ts ~107-118; the closure in parsing-processor.ts/parse-worker.ts/call-processor.ts.)
• [P2 · latent] classIdCache/classInfoCache key on the node ref only, not on getQualifiedOwnerName presence — the call-scope path calls without the hook, the definition path with it. Latent today (distinct node refs) but fragile; harden by keying on hook presence or always threading it. (Converged across the performance, risk, and maintainability lanes.)
• [P2 · code-read] Ruby worker-path untested: the Ruby fix touches parse-worker.ts (main owner + the kind==='properties' block), but only the sequential path is tested; C++ has a worker-parity test. Add a Ruby worker-parity test (workerThresholdsForTest:{minFiles:1} + usedWorkerPool).
• [P2/P3 · maintainability] the qualifier lambda + qualifiedClassId ?? classId fallback are duplicated across 4 sites kept "in lockstep" only by comment — extract a ClassExtractor helper; strengthen the "order is load-bearing" comment to name the failure mode; reconsider the qualifiedNodeId boolean name (vs the isTypeDeclaration convention).
• [P3] the C++ worker-path test omits the sourceId-not-:: discriminator that the sequential #1975 test uses to prove the fix is engaged.

Validated (a feature, not a finding)

The owner-id==node-id invariant survived adversarial templated/specialized/deep-nested probing; the hoist purity and the guard logic were probed and found sound; normalizeQualifiedName collapses only genuinely-same types.

Test gaps

No fixtures for heritage-to-nested-base, templated-nested ownership, nested enums/interfaces, 3-level nesting, or the Ruby worker-path; the same-named-method-under-same-tail residual (#1982) isn't pinned.

Coverage

Full 15-file diff read + targeted coordinator pipeline reproductions (heritage, union, anon-namespace). Worker-path assertions can't execute in a no-build worktree (validated by code-read + the C++ worker-parity test that runs in CI).

Automated multi-tool digest — mostly one engine (Claude) across personas, plus one coordinator-verified Codex lead. Verify findings before acting.

[magyargergo]

Tri-review (delta) — #1982 resolution-side: same-tail nested-type identity for C++/Ruby

Scope. Delta review of the new issue #1982 resolution-side work added since the prior pr-tri-review (which covered the #1978 structure phase and is left intact). Reviews only the resolution commits: qualified-first inheritance base resolution (resolveQualifiedInheritanceBase), the @reference.qualified-name / rawQualifiedName plumbing, the shared normalizeQualifiedName, and the Ruby full-qualified __heritage__/__property__ owner keying — the part the prior review deferred to #1982. Reviewed at head b9286bb9 (now CLEAN, caught up with main).

Verdict: needs changes before merge. One reproduced P1 regression (Ruby) introduced by this PR, plus one reproduced P2 incomplete-fix (C++) where the headline deliverable is a no-op for the common case. Neither is caught by CI. The structure-phase work and the owner-side same-tail fix (the parts with tests) are solid.

Methods & engine breakdown (read first). 5 Claude reviewer personas returned full findings (correctness, adversarial, maintainability, testing, performance); the 2 GitNexus lanes (risk, test/CI) ended mid-investigation, their domains covered by the others plus coordinator verification. Codex (gpt-5.5, xhigh) was dispatched but produced no retrievable structured output — weight this as a Claude-method review (several personas, one engine), not three independent confirmations. The two headline findings were each reproduced end-to-end twice (the adversarial persona + an independent verification agent, each running the full integration pipeline on BASE vs HEAD) — that reproduction, not persona agreement, is the strong signal here.

Headline — [P1 · reproduced · blocks merge] Ruby nested mixin included by short name silently drops its IMPLEMENTS edge

Inlined on ruby/scope-resolver.ts:32. emitRubyMixinEdges now keys graphIdByName by the full def.qualifiedName (line 32), but the mixin target is still looked up by its as-written short name (graphIdByName.get(mixinName), line 52, mixinName = arg.text). For

module App
  module Loggable; def log; end; end
  class Service; include Loggable; end
end

the edge resolves on BASE (App.Service -IMPLEMENTS-> Loggable) but is dropped on HEAD (reproduced on both trees). The owner side was upgraded to full-qualified on both the marker and the map key; the mixin side was left asymmetric (map = full qn, lookup = bare name). Blast radius: every include/extend/prepend of a nested/namespaced module by short name — common in Rails/gem code — loses its IMPLEMENTS edge and MRO entry, with 0 dangling edges so findDanglingEdges can't catch it. The new fixture uses only top-level mixin modules, so CI stays green and the regression is untested. Fix: resolve the mixin reference to the same qualified key the def is registered under (progressive-prefix against the enclosing scope), or keep a simple-tail fallback; add a nested-mixin-by-short-name fixture.

Headline — [P2 · reproduced · merge decision] C++ same-tail nested heritage is a no-op once wrapped in a namespace

Inlined on walkers.ts:343. The new resolveQualifiedInheritanceBase correctly picks the right def, but the result is defeated downstream: for a type inside a namespace the scope-model def.qualifiedName omits the namespace (B.Inner), while the structure-phase graph node carries it (NS.B.Inner). resolveDefGraphId (scope-resolution/graph-bridge/ids.ts, unchanged) then misses the qualifiedKey and falls back to simpleKey('Inner'), collapsing both same-tail bases (and both Derived callers) onto the first-inserted node — so the second derivation's EXTENDS is suppressed as a duplicate (reproduced: NS.DB.Derived gets no EXTENDS edge). Not a regression (BASE behaves identically) — but the C++ deliverable only works for top-level types, and the shipped shapes.cpp fixture is top-level-only, giving false confidence. The merge decision: blocks if #1982 is meant to fix namespaced C++ heritage; acceptable if this PR's C++ scope is intentionally top-level-only (then document the limitation and add the namespaced fixture as a known gap). Fix: thread the namespace into the scope-model qualifiedName so qualifiedKey hits, or add a namespace-suffix fallback in resolveDefGraphId. (Ruby's same-tail attr/mixin owner-identity tests pass — this is C++-specific.)

Secondary (body only — not blocking)

• [P2 · testing] rust.test.ts's Rust inline mod-nested same-tail collision block is describe.skip (Rust impl-item ownership deferred), yet rust-nested-tail-collision/lib.rs is registered in the captures golden — zero active assertions behind a registered fingerprint reads as coverage that doesn't exist. Add a minimal active assertion (two distinct Struct nodes, no dangling HAS_METHOD) or drop the fingerprint-only entry.
• [P2 · testing] Ruby worker-path parity asserts only attr_accessor (HAS_PROPERTY); the worker mixin (IMPLEMENTS) path — where rawQualifiedName / the marker owner must survive worker serialization — is untested. The C++ worker heritage test asserts only DerivedB and lacks a toHaveLength(1) duplicate guard.
• [P2 · maintainability] Three sites must now agree byte-for-byte (the Ruby marker owner from buildEnclosingQualifiedName, the graphIdByName key from def.qualifiedName, and the structure-phase qualifiedName) — comment-enforced only, no shared encode/decode pair. cpp/captures.ts also keeps a parallel normalizeCppNamespaceQName instead of importing the new shared normalizeQualifiedName (the file's stated single-normalizer goal); PROPERTY_PREFIX is function-scoped while HERITAGE_PREFIX is module-scoped.
• [P3 · perf] resolveInheritanceBaseInScope + preEmitInheritanceEdges walk findEnclosingClassDef twice per qualified site; buildEnclosingQualifiedName walks to the AST root per heritage/attr call with no per-class memo or program early-exit. Gated to C++/Ruby and bounded by nesting depth — minor, but memoize if it shows on the bench given this repo's O(n²) scope history.
• [P3 · pre-existing, not a #1982 regression] A qualified mixin arg include Outer::Mixin corrupts the :-delimited __heritage__ marker (arg.text contains ::) → split mis-parses → edge dropped. Present on BASE too, but adjacent and worth fixing with the rest.
• [P3 · niche] normalizeQualifiedName strips a leading ::, so an explicitly-global C++ base : ::Net::X could bind to an enclosing-relative same-path type if one exists. Narrow; no fixture.

Validated (a feature, not a finding)

Probed and refuted: scopes.qualifiedNames.get() returns a frozen empty array on miss → the new .length access is crash-safe; refuse-on-tie returns undefined and falls through to the unchanged simple-tail walk, so no base that previously resolved becomes unresolved; unqualified bases and the flag-OFF path are byte-identical to BASE; ordering is sound (populateOwners runs before preEmitInheritanceEdges); normalizeQualifiedName collapses only genuinely-equivalent forms. The owner-side same-tail fix (the part with tests) works on both legs.

CI & branch state

All checks green on the reviewed head — including scope-parity / scope-resolution parity (the registry-primary leg that runs the #1982 assertions), tests / ubuntu / coverage, all platform tests, benchmarks, and tree-sitter ABI. Branch is a clean feature/fix branch, now mergeable / CLEAN (caught up with main; merge-from-main churn from #1984/#1976/#1980/#1974/#1987 excluded via merge-base and not reviewed). CI passing does not cover the two reproduced gaps — both the C++ heritage and Ruby mixin fixtures are top-level-only.

Coverage

Full read of the 9 #1982 source files + the new tests/fixtures; both headline findings reproduced end-to-end on BASE vs HEAD via the integration pipeline.

Automated multi-tool digest — one engine (Claude) across several personas, Codex unavailable, two findings reproduced end-to-end. Verify before acting.