feat(cha): extend hierarchy extraction to Kotlin/PHP/Swift/Scala + harden cross-file resolution

CHA was INERT for Kotlin, PHP, Swift, and Scala — they extract classes but
extractClassRelationships had no branch for them (the C# defect, x4: zero inheritance edges
-> zero override/dispatch edges). Added a branch for each (Kotlin/Swift via delegation/
inheritance specifiers; PHP splitting base_clause/extends vs class_interface_clause/implements;
Scala via extends_clause + a new getScalaParser). Ruby/Go already worked; C++ has a branch.

Real-repo dogfood (DesignPatternsPHP, kotlinx.coroutines) confirmed correct edges at scale
(PHP 71, Kotlin 157 override edges) AND surfaced two false-positive bugs, both fixed:
- Cross-file/cross-namespace same-name collision -> false override edge (two unrelated `Logger`/
  `Formatter` interfaces in different PHP namespaces). Fixed in buildClassNodes: when a base name
  is not same-file AND ambiguous, SKIP rather than global-first-match — false-negatives over
  false-positives. (FQCN/namespace-aware resolution is the future enhancement.)
- Kotlin qualified supertype mis-captured: `Job : CoroutineContext.Element` matched the outer
  `CoroutineContext` (a phantom from extension-function receivers), fabricating overrides. Fixed
  by taking the supertype leaf name and skipping qualified (dotted) types; applied to Swift too.
  Generic supertypes (`Segment<T>`) still resolve to `Segment`.

Test-covered the last unproven scenario: override propagation through the DB-backed lazy path
(bfsFromDB) — traversed by default, excluded under directResolvedOnly, matching buildAdjacency.

CHA hierarchy support now: TS/JS, Python, Java, C++, C#, Ruby, Go, Kotlin, PHP, Swift, Scala.
Tests +8; full suite green (3762). Decisions: bf52c392, d5967a48, 9d87726f.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: clay-good

openspec/changes/archive/add-type-hierarchy-resolved-dispatch/tasks.md

@@ -65,6 +65,36 @@
 > dispatch path matches by name only (arity is enforced on the override path). Tests: +7
 > (`type-inference-engine.test.ts` Java/C# `var new T`; `cha.test.ts` cross-file resolution + C#
 > override edges). Full suite green (3754).
+>
+> **Multi-language coverage + dogfood pass (follow-up, same PR #155).** Auditing
+> `extractClassRelationships` against the languages OpenLore parses revealed CHA was **inert for
+> Kotlin, PHP, Swift, and Scala** — they extract classes but had no hierarchy-extraction branch (the
+> exact C# defect, ×4: zero inheritance edges → zero override/dispatch edges). Added a branch for each
+> (Kotlin/Swift via delegation/inheritance specifiers, PHP splitting `base_clause` vs
+> `class_interface_clause`, Scala via `extends_clause` + a new `getScalaParser`). Ruby and Go already
+> worked; C++ has a branch (its abstract-pure-virtual-base case is the documented node boundary).
+> Real-repo dogfood (DesignPatternsPHP, kotlinx.coroutines) confirmed correct edges at scale (PHP 71,
+> Kotlin 157 override edges) **and** surfaced two false-positive bugs, both fixed:
+> - **Cross-file / cross-namespace same-name collision → false override edge.** Two unrelated `Logger`
+>   (and `Formatter`) interfaces in different PHP namespaces: the child's implementers live in other
+>   files, so same-file-first missed and the global first-match wired the wrong twin (and *stole* the
+>   real edge). Fixed language-agnostically in `buildClassNodes`: when a base name is not same-file
+>   AND is ambiguous (several classes share it across files), **skip** rather than guess —
+>   false-negatives over false-positives. (Cost: some legitimate reused-name cross-file edges are also
+>   skipped; namespace/FQCN-aware resolution is the future enhancement, like RTA/VTA pruning.)
+> - **Kotlin qualified supertype mis-captured.** `interface Job : CoroutineContext.Element` matched the
+>   outer segment `CoroutineContext` (a phantom class from extension-function receivers `fun
+>   CoroutineContext.x()`), synthesizing false `CoroutineContext.x → Job.x` overrides. Fixed by taking
+>   the supertype's leaf name and **skipping qualified types** (`Outer.Inner`); applied to Swift too
+>   (identical `user_type` structure, same latent bug). Generic supertypes (`Segment<T>`) still
+>   resolve correctly to `Segment`.
+>
+> Also verified the last unproven scenario end-to-end: **override propagation through the DB-backed
+> lazy path** — a `bfsFromDB` test (real `EdgeStore`) confirms override edges are traversed by default
+> and excluded under `directResolvedOnly`, matching the in-memory `buildAdjacency` path. Tests: +8
+> (`cha.test.ts` Kotlin/PHP/Swift/Scala override + ambiguous-cross-file + Kotlin-qualified-supertype;
+> `graph.test.ts` bfsFromDB DB-path propagation). Full suite green (3762). Languages with CHA hierarchy
+> support: TS/JS, Python, Java, C++, C#, Ruby, Go, Kotlin, PHP, Swift, Scala.
 
 ## 1. Confirm the surface is purely additive (no type changes)
 - [x] Verify `EdgeConfidence` already includes `'synthesized'` (`call-graph.ts:34`), `CallEdge` already

openspec/specs/analyzer/spec.md

@@ -5553,6 +5553,24 @@ The system SHALL resolve base-class references to same-file declarations before
 
 > Decision recorded: 66e47bb4
 > Date: 2026-06-17
+### Requirement: ExtendChaHierarchyExtractionToKotlinphpswiftscalaWithAmbiguityskipAndQualifiedsupertypeskipGuards
+
+The system SHALL extract class-hierarchy relationships for Kotlin, PHP, Swift, and Scala, skipping ambiguous cross-file base names and qualified supertypes to avoid false-positive dispatch edges.
+
+> Decision recorded: 9d87726f
+> Date: 2026-06-17
+### Requirement: ExtendChaTypehierarchyExtractionToKotlinPhpSwiftAndScala
+
+The system SHALL extract class-hierarchy relationships (extends/implements/mixin edges) from Kotlin, PHP, Swift, and Scala source files using tree-sitter grammars.
+
+> Decision recorded: bf52c392
+> Date: 2026-06-17
+### Requirement: AmbiguousCrossfileParentResolutionPrefersFalsenegativeOverFalsepositive
+
+The system SHALL skip cross-file parent resolution when the parent name is ambiguous (declared in more than one file), preferring false-negatives over false-positives in inheritance edges.
+
+> Decision recorded: d5967a48
+> Date: 2026-06-17
 
 ## Technical Notes
 
@@ -6020,3 +6038,33 @@ Route-matching regexes use character offsets (m.index) that are resolved to line
 Adversarial dogfooding CHA on real OO corpora (java-design-patterns, python-patterns, dotnet/samples) surfaced three defects: (1) global first-match base-class resolution linked unrelated same-named classes across files — fixed by preferring same-file ClassNode resolution before global fallback; (2) type-inference required uppercase declared types, so Java 10+/C# `var x = new T()` locals recovered no type and virtual calls fell to broad cha-name-arity — fixed by adding var-new-T matchers for Java and C#; (3) no C# branch in extractClassRelationships left CHA inert for C# — fixed by adding a C# branch over base_list, splitting base-class vs interface by I<Upper> naming convention.
 
 **Consequences:** Same-file base resolution eliminates cross-file name collisions (empty same-file base still falls back to global — rare, documented). var-new-T recovery converts many heuristic cha-name-arity edges into precise type_inference edges (Java cha-name-arity 113→65 on design-patterns slice). C# CHA now functional (0→81 inheritance / 59 override edges on slice). Residual cha-name-arity over-approximation remains for non-locally-recoverable receivers; field-type tracking / RTA-VTA pruning stay out-of-scope per HighPrecisionCHABounds.
+
+### Extend CHA hierarchy extraction to Kotlin/PHP/Swift/Scala with ambiguity-skip and qualified-supertype-skip guards
+
+**Status:** Approved
+**Date:** 2026-06-17
+**ID:** 9d87726f
+
+CHA was inert for Kotlin, PHP, Swift, and Scala because extractClassRelationships had no branch for them, producing zero inheritance and dispatch edges. Added hierarchy-extraction branches for each language (Kotlin/Swift via delegation/inheritance specifiers; PHP distinguishing extends from implements; Scala via extends_clause with a new getScalaParser). Real-repo dogfooding then surfaced two false-positive bugs: (1) cross-file/cross-namespace same-name class collisions wired by the global first-match fallback — fixed by skipping resolution when a base name is non-same-file AND ambiguous; (2) Kotlin/Swift qualified supertypes (Outer.Inner) mis-captured the outer segment as the base — fixed by taking the leaf name and skipping dotted types.
+
+**Consequences:** CHA now has hierarchy support for 11 languages (TS/JS, Python, Java, C++, C#, Ruby, Go, Kotlin, PHP, Swift, Scala). The ambiguity-skip is language-agnostic and eliminates cross-file collision false positives everywhere, at the cost of skipping legitimate cross-file override edges whose base name is reused (FQCN/namespace-aware resolution is the future enhancement). Swift/Scala protocol/trait abstract methods without bodies are not extracted as nodes, so only concrete-base hierarchies get edges.
+
+### Extend CHA type-hierarchy extraction to Kotlin, PHP, Swift, and Scala
+
+**Status:** Approved
+**Date:** 2026-06-17
+**ID:** bf52c392
+
+The polymorphic-dispatch (CHA) feature requires class-hierarchy edges for each supported language; adding tree-sitter-based extraction for these four languages broadens the cross-language coverage of resolved virtual-call edges.
+
+**Consequences:** New runtime dependency on tree-sitter-scala; each language follows the same pattern (lazy parser init + query-based extraction) so maintenance cost is linear; qualified/nested type names are deliberately skipped to avoid phantom edges.
+
+### Ambiguous cross-file parent resolution prefers false-negative over false-positive
+
+**Status:** Approved
+**Date:** 2026-06-17
+**ID:** d5967a48
+
+When multiple classes share a bare name across different files (e.g. two unrelated `Logger` interfaces in different PHP namespaces), a global first-match would fabricate a false override edge and steal the real one from the correct twin; skipping the resolution entirely is safer for downstream dispatch accuracy.
+
+**Consequences:** Some legitimate cross-file inheritance edges will be missed when name collisions exist; this is an acceptable precision-over-recall tradeoff that avoids polluting the call graph with phantom dispatch targets.

src/core/analyzer/call-graph.ts

@@ -459,6 +459,7 @@ let _swiftParser: Parser | undefined;
 let _phpParser: Parser | undefined;
 let _csParser: Parser | undefined;
 let _ktParser: Parser | undefined;
+let _scalaParser: Parser | undefined;
 let _exParser: Parser | undefined;
 
 // null = tried and unavailable; undefined = not yet tried
@@ -489,6 +490,7 @@ let _SwiftLanguage: object | undefined;
 let _PhpLanguage: object | undefined;
 let _CsLanguage: object | undefined;
 let _KtLanguage: object | undefined;
+let _ScalaLanguage: object | undefined;
 let _ExLanguage: object | undefined;
 
 async function getTSParser(): Promise<{ parser: Parser; lang: object } | null> {
@@ -599,6 +601,18 @@ async function getKotlinParser(): Promise<{ parser: Parser; lang: object } | nul
   return { parser: _ktParser!, lang: _KtLanguage! };
 }
 
+async function getScalaParser(): Promise<{ parser: Parser; lang: object } | null> {
+  const NP = await loadNativeParser();
+  if (!NP) return null;
+  if (!_scalaParser) {
+    const scalaModule = await import('tree-sitter-scala');
+    _ScalaLanguage = (scalaModule as { default: object }).default;
+    _scalaParser = new NP();
+    _scalaParser.setLanguage(_ScalaLanguage as unknown as Parser.Language);
+  }
+  return { parser: _scalaParser!, lang: _ScalaLanguage! };
+}
+
 async function getElixirParser(): Promise<{ parser: Parser; lang: object } | null> {
   const NP = await loadNativeParser();
   if (!NP) return null;
@@ -2739,6 +2753,92 @@ async function extractClassRelationships(
           }
         }
 
+      } else if (file.language === 'Kotlin') {
+        const r = await getKotlinParser();
+        if (!r) continue;
+        const { parser, lang } = r;
+        const tree = (parser as Parser).parse(file.content);
+
+        // Kotlin `class C : Base(), IFace` — every supertype is a `delegation_specifier`
+        // with no syntactic class/interface distinction (a superclass may carry a
+        // constructor_invocation). Capture the whole user_type and take its leaf name,
+        // SKIPPING qualified types (`Outer.Inner`, e.g. `Job : CoroutineContext.Element`):
+        // those resolve to a nested/stdlib type, and matching the outer segment wires the
+        // class to a phantom (an extension-function receiver such as `CoroutineContext`).
+        for (const declType of ['class_declaration', 'object_declaration', 'interface_declaration']) {
+          for (const wrap of ['(user_type) @put', '(constructor_invocation (user_type) @put)']) {
+            const Q = `(${declType} (type_identifier) @cls (delegation_specifier ${wrap}))`;
+            for (const m of safeQuery(lang, Q, tree.rootNode)) {
+              const cls = m.captures.find(c => c.name === 'cls')?.node.text;
+              const put = m.captures.find(c => c.name === 'put')?.node.text;
+              if (!cls || !put) continue;
+              const parent = put.replace(/<[\s\S]*$/, '').trim(); // strip generic args
+              if (parent.includes('.')) continue;                 // skip qualified/nested types
+              merge(file.path, cls, [parent], []);
+            }
+          }
+        }
+
+      } else if (file.language === 'PHP') {
+        const r = await getPhpParser();
+        if (!r) continue;
+        const { parser, lang } = r;
+        const tree = (parser as Parser).parse(file.content);
+
+        // PHP distinguishes `extends` (base_clause, one parent) from `implements`
+        // (class_interface_clause, many interfaces).
+        const EXTENDS_Q = `(class_declaration name: (name) @cls (base_clause (name) @parent))`;
+        const IMPLEMENTS_Q = `(class_declaration name: (name) @cls (class_interface_clause (name) @iface))`;
+        for (const m of safeQuery(lang, EXTENDS_Q, tree.rootNode)) {
+          const cls    = m.captures.find(c => c.name === 'cls')?.node.text;
+          const parent = m.captures.find(c => c.name === 'parent')?.node.text;
+          if (cls && parent) merge(file.path, cls, [parent], []);
+        }
+        for (const m of safeQuery(lang, IMPLEMENTS_Q, tree.rootNode)) {
+          const cls   = m.captures.find(c => c.name === 'cls')?.node.text;
+          const iface = m.captures.find(c => c.name === 'iface')?.node.text;
+          if (cls && iface) merge(file.path, cls, [], [iface]);
+        }
+
+      } else if (file.language === 'Swift') {
+        const r = await getSwiftParser();
+        if (!r) continue;
+        const { parser, lang } = r;
+        const tree = (parser as Parser).parse(file.content);
+
+        // Swift `class C: Base, Proto` — every supertype/protocol is an
+        // `inheritance_specifier` with no syntactic distinction. (class_declaration in
+        // this grammar also covers struct/enum/extension.) Take the user_type leaf name
+        // and skip qualified types (`Module.Type`) for the same reason as Kotlin.
+        for (const declType of ['class_declaration', 'protocol_declaration']) {
+          const Q = `(${declType} (type_identifier) @cls (inheritance_specifier (user_type) @put))`;
+          for (const m of safeQuery(lang, Q, tree.rootNode)) {
+            const cls = m.captures.find(c => c.name === 'cls')?.node.text;
+            const put = m.captures.find(c => c.name === 'put')?.node.text;
+            if (!cls || !put) continue;
+            const parent = put.replace(/<[\s\S]*$/, '').trim();
+            if (parent.includes('.')) continue;
+            merge(file.path, cls, [parent], []);
+          }
+        }
+
+      } else if (file.language === 'Scala') {
+        const r = await getScalaParser();
+        if (!r) continue;
+        const { parser, lang } = r;
+        const tree = (parser as Parser).parse(file.content);
+
+        // Scala `class C extends Base with Trait` — the superclass and every mixed-in
+        // trait sit in one `extends_clause`. Treat each as a subtype edge.
+        for (const declType of ['class_definition', 'trait_definition', 'object_definition']) {
+          const Q = `(${declType} (identifier) @cls (extends_clause (type_identifier) @parent))`;
+          for (const m of safeQuery(lang, Q, tree.rootNode)) {
+            const cls    = m.captures.find(c => c.name === 'cls')?.node.text;
+            const parent = m.captures.find(c => c.name === 'parent')?.node.text;
+            if (cls && parent) merge(file.path, cls, [parent], []);
+          }
+        }
+
       } else if (file.language === 'Ruby') {
         const r = await getRubyParser();
         if (!r) continue;
@@ -2863,11 +2963,22 @@ function buildClassNodes(
   // (a class extending a base declared in its own file / a same-named local shadow);
   // genuine cross-file inheritance falls back to the global first match.
   const byName = new Map<string, ClassNode>();
+  const nameCount = new Map<string, number>();
   for (const cls of classMap.values()) {
+    nameCount.set(cls.name, (nameCount.get(cls.name) ?? 0) + 1);
     if (!byName.has(cls.name)) byName.set(cls.name, cls);
   }
-  const resolveParent = (parentName: string, childFile: string): ClassNode | undefined =>
-    classMap.get(`${childFile}::${parentName}`) ?? byName.get(parentName);
+  const resolveParent = (parentName: string, childFile: string): ClassNode | undefined => {
+    const sameFile = classMap.get(`${childFile}::${parentName}`);
+    if (sameFile) return sameFile;
+    // The base is not declared in the child's file and its bare name is AMBIGUOUS
+    // (several classes share it across files — e.g. two unrelated `Logger` interfaces
+    // in different PHP namespaces). A global first-match would both fabricate a false
+    // override edge AND steal the real one from the correct twin, so skip rather than
+    // guess — false-negatives over false-positives.
+    if ((nameCount.get(parentName) ?? 0) > 1) return undefined;
+    return byName.get(parentName);
+  };
 
   const inheritanceEdges: InheritanceEdge[] = [];
   const seenEdges = new Set<string>();