TypeScript: calls through an imported singleton instance resolve to the exported constant instead of the class method

[lxy32167]

Summary

In TypeScript, an instance method call through a singleton is resolved correctly
when the singleton is used in the file where it is created, but the equivalent
call is mis-resolved after importing that singleton from another file.

For the imported call, CodeGraph emits a calls edge to the exported constant
instead of the class method. As a result, codegraph callers <method> misses the
cross-file caller and can make the method appear unused.

This reproduces on a fresh index built with CodeGraph 1.4.1.

Minimal reproduction

src/store.ts:

export class ReproStore {
  notifyJoinGuildStatus(): void {
    console.log('notified');
  }
}

export const reproStore = new ReproStore();

export function callInDefinitionFile(): void {
  reproStore.notifyJoinGuildStatus();
}

src/caller.ts:

import { reproStore } from './store';

export function callFromImportedFile(): void {
  reproStore.notifyJoinGuildStatus();
}

Build a fresh index and query the method and exported constant:

codegraph init .
codegraph callers notifyJoinGuildStatus -p . -j
codegraph callers reproStore -p . -j

Actual behavior

codegraph callers notifyJoinGuildStatus returns only the same-file caller:

callInDefinitionFile -> ReproStore::notifyJoinGuildStatus

The cross-file caller is instead attached to the exported constant:

callFromImportedFile -> reproStore

The corresponding graph edges are resolved as follows:

callInDefinitionFile
  -> notifyJoinGuildStatus (method)
     {"confidence":0.8,"resolvedBy":"instance-method","refName":"reproStore.notifyJoinGuildStatus"}

callFromImportedFile
  -> reproStore (constant)
     {"confidence":0.9,"resolvedBy":"import","refName":"reproStore.notifyJoinGuildStatus"}

Expected behavior

Both functions should have a calls edge to
ReproStore::notifyJoinGuildStatus:

callInDefinitionFile  -> ReproStore::notifyJoinGuildStatus
callFromImportedFile  -> ReproStore::notifyJoinGuildStatus

The import may still reference the reproStore constant, but the member
invocation should not be represented as a call to that constant.

Environment

CodeGraph: 1.4.1
Language: TypeScript
Platform: macOS arm64
Index: full rebuild; pendingRefs=0

[colbymchenry]

Fixed in #1315 (merged to main, ships in the next release). Your edge dump captured the divergence perfectly — same-file calls went through instance-method inference, cross-file calls stopped at the import match and linked the constant.

The import resolver now descends through imported values the way it already did for Class.staticMember: when the base of a dotted call resolves to an exported constant/variable, its type is inferred from its own declaration in the exporting file (= new ReproStore() or a type annotation), and the member is resolved on that class — with validation, so a failed inference keeps the old constant edge rather than fabricating anything. Your exact two-file repro is now a regression test asserting callers notifyJoinGuildStatus returns both functions.

Note the resulting edge reports resolvedBy: "instance-method" (confidence 0.85), matching the same-file form. A codegraph index -f after upgrading rebuilds the edges.