[danusha2345]

Problem

A call to a member of the caller's own class is resolved as if it were ambiguous. This covers a bare call, which means this.m() in Java, Kotlin, C#, Scala, Swift, C++, Dart and Ruby, and an explicit this./self./$this->/super. call. The extractor drops those receivers, so all of them reach the resolver as the bare name.

findBestMatch then breaks ties between same-file candidates by line distance. Nothing asks which class the caller is in, so a sibling class's same-named method wins at 0.4 when it's closer:

• render() inside RegName.toString() resolves to IPv4.render.
• super.onCreate() becomes a self-loop.
• An inherited gcs() inside ModeX::run goes to Copter::gcs instead of Mode::gcs.

I reproduced it on main for Java, Kotlin, C#, Scala, Swift, C++ (inline and out-of-line members), Dart, Ruby, PHP $this->, Python self. and TypeScript this..

Fix

matchEnclosingScopeMember runs in matchByExactName before the ambiguity ceiling and findBestMatch. It reads the receiver back from the call line: bare, a self-receiver, or super. It then walks the caller's scopes from the inside out and returns the first match at 0.9, the same confidence as a typed match:

1. the enclosing class's own member;
2. inherited members, only from supertypes that the class's declaration names;
3. for bare calls only, outer classes and enclosing functions.

Guards:

• super. skips its own class and never lands on an interface or abstract declaration.
• A constructor-shaped call isn't bound to a member.
• Same-named supertypes in another language are ignored.
• The walk stops before an outer class when the inner class extends a type that isn't indexed, such as Android View or an anonymous class, since that parent might declare the name.

When nothing matches, the existing ranking applies. A class member now wins over a same-named top-level function, which follows the Kotlin, C++ and Swift scoping rules.

Measured (main ba3c21e vs this branch; node counts unchanged everywhere)

corpus	changed edges	checked
MediatR, Go app, Rust app, small Kotlin app	0	—
Kotlin apps	1 + 1	correct
Flask	1	correct
Kotlin/C/PHP app	4	correct (parent::__construct self-loops ×3, $this->fixlinks)
Slim (PHP)	147	all correct
ArduPilot ArduCopter + 4 libraries (C++)	163	35 checked, all correct
playframework	1,803 retargeted + 112 new	~120 checked, e.g. ResultExtractors::status, FutureAwaits::await, BaseController::Action (previously unresolved or an unrelated spec at 0.4)
decompiled Android SystemUI (Java)	2,813 lost / 2,806 gained	~80 checked: mostly super.x() self-loops and inherited getContext/getChildCount that went to unrelated classes

About 350 changed edges were checked by hand, and none has a wrong target. Indexing time is within noise: SystemUI took 42.7 s and 59.0 s on main and 47.5 s and 61.3 s with this branch, on a loaded machine.

It composes with #1938 and #1936: this path returns before theirs, and all tests pass together.

Known limits:

• In Kotlin with(x) { render() }, the lambda receiver should win, but the enclosing class is picked. On main this was a proximity guess anyway.
• Inheritance relies on supertype edges already existing when the ref resolves. If they don't yet, the old ranking applies.

Tests

The new __tests__/enclosing-class-member-call.test.ts has 20 cases:

• 16 fail on main: the 12 language cases, a Java inner class calling its outer class, an inherited member, super.render(), and same-named nested Builder types.
• 4 guards: a top-level function with no competing member, an inner class with an unindexed parent, super. never landing on an interface, and Kotlin member vs top-level function.

The full suite passes: 275 files, 4736 tests.

🤖 Generated with Claude Code

[danusha2345]

Rebased onto main and narrowed. Main now confines a bare call to what is in scope for Kotlin, C#, Swift, Dart, Ruby and PHP (#2172, #2151, #2170, #2145, #2147, #2142) and Java via #2126, so 13 of the 20 cases pass there and are dropped with their language branches. What remains, all failing on main: Scala and C++ bare calls, Python self. and TS this. (going to B::render instead of the caller's A::render), Java super.render() (no edge on main), and two same-named nested Java classes. One original case — a nested Java class whose supertype is outside the index should not get the outer class's method — is dropped: under #2126 main treats the outer Outer::render as the right answer, and changing that would mean changing main's Java rule.

🤖 Generated with Claude Code

[danusha2345]

Rebased onto main (2344ce0) and amended for #2612, whose cpp-free-function-overloads suite this branch failed as it stood: the enclosing-scope member pick ran before the argument-fit choice, so Store(1) in namespace pb took the first Store overload in the file. C++ overloads of one free function in the caller's namespace now fall through to the pick below — the overload the arguments fit, else the nearest — exactly as on main. The rest of the change is unchanged; full suite green on this head.

[danusha2345]

Rebased on main 16a8e77, with one follow-up for the super-call reading main gained in #2818 (7776ad1):

• A super.run() inside a class expression's method is recorded from the enclosing method (the expression's members have no nodes), and main's matchJsSuperCall declines to place it. The enclosing-scope pick then read it as the enclosing class's run and sent it to that class's parent — Holder::make -> Base::run in main's JavaScript: aliased constructor receivers and overridden super calls remain unresolved #2497 test, where the super is Other. A call written on super now skips the pick and takes the strategies after it, as on main.
• main's js-class-expressions test pinned Widget::extra -> Widget::run at exact-match 0.4 (a proximity guess). this.run() inside the class expression is Widget's own member, so this branch gives the same edge at 0.9 by evidence; the test now expects that.

Full suite on 16a8e77 with the native kernel (CODEGRAPH_KERNEL_EXPECT=1): 8,922 passed, 37 skipped, 0 failed; tsc --noEmit clean.

[colbymchenry]

Thanks @danusha2345, this landed as #2950 with you as the commit author. Resolving a call through the caller's own class before the line-distance ranking pays off widely: across 15 repos it moved about 7,400 links to the right method, among them Django test cases' self.settings(), vscode's this._register()/this.dispose() and Play's controllers, and it linked a few hundred super calls that had no link before. We made three changes on top:

• Inherited members now come from the class's own resolved extends/implements edges, in header order, a concrete class before an interface's declaration, with your walk by name as the fallback. By name, Django's per-backend DatabaseSchemaEditors and classes with two bases took the wrong parent.
• Only super/this/self (and Python's cls) count as the receiver, since Java variables named parent or cls reach the resolver the same way.
• C++ is left to the C++ member lookup that main already has, because its namespace-level pick beat the overload the arguments fit (fmt's copy).

It ships in the next release.