Interface ResolutionContext

src/resolution/types.ts:90–215

 * Context for resolution - provides access to the graph
 */
export interface ResolutionContext {
  /** Get all nodes in a file */
  getNodesInFile(filePath: string): Node[];
  /** Whether any node in the file is exported (`getNodesInFile(f).some(n => n.isExported)`), as one indexed probe. */
  fileHasExportedNode?(filePath: string): boolean;
  /** `getNodesInFile(f).filter(n => n.isExported)`, without decoding the rest of the file. */
  getExportedNodesInFile?(filePath: string): Node[];
  /** `getNodesInFile(f).filter(n => n.name === name)`, without decoding the rest of the file. */
  getNodesInFileNamed?(filePath: string, name: string): Node[];
  /** Get all nodes by name */
  getNodesByName(name: string): Node[];
  /** Get all nodes by qualified name */
  getNodesByQualifiedName(qualifiedName: string): Node[];
  /** Get all nodes of a kind */
  getNodesByKind(kind: Node['kind']): Node[];
  /**
   * Stream nodes of a kind one at a time instead of materializing (and, unlike
   * `getNodesByKind`, without populating the resolver's per-kind array cache).
   * For unbounded kinds (`function`, `method`, `struct`) on a symbol-dense
   * project the full array is gigabytes — the dynamic-edge synthesizers must
   * use this so their memory stays O(1) in node count (#610, #1212). Optional
   * so minimal test contexts compile; callers fall back to getNodesByKind.
   */
  iterateNodesByKind?(kind: Node['kind']): IterableIterator<Node>;
  /** Check if a file exists */
  fileExists(filePath: string): boolean;
  /** Read file content */
  readFile(filePath: string): string | null;
  /** `readFile(filePath)?.includes(needle) ?? false` for an ASCII `needle`, without decoding a file that lacks it. */
  fileContains?(filePath: string, needle: string): boolean;
  /**
   * `readFile(filePath)` split into lines, LRU-cached per file. Receiver-type
   * inference scans source lines for EVERY `receiver.method()` ref; splitting
   * the whole file per ref made that O(refs-in-file × file-size) — ~20% of
   * total index CPU on a Java-heavy repo and a driver of the #1122 watchdog
   * kill on large ones. Optional so external/test contexts compile without it;
   * callers fall back to splitting `readFile` themselves.
   */
  getFileLines?(filePath: string): string[] | null;
  /**
   * The method-definition nodes matching `typeName::methodName` in the language family —
   * exactly `resolveMethodOnType`'s kind/language/qualifiedName-suffix filter,
   * LRU-cached per (language, type, method). The uncached path re-fetches every
   * node sharing the METHOD name (unbounded — tens of thousands on a collision-
   * heavy Java repo) and re-scans it per ref, the dominant term in the #1122
   * watchdog kill. Cached entries hold only the small filtered result; per-ref
   * disambiguation (import FQN, call-site file) stays in the caller so a cached
   * entry is valid from any call site. Optional for external/test contexts.
   */
  getMethodMatches?(typeName: string, methodName: string, language: Language): Node[];
  /** Get project root */
  getProjectRoot(): string;
  /** Get all files */
  getAllFiles(): string[];
  /** Get nodes by lowercase name (O(1) lookup for fuzzy matching) */
  getNodesByLowerName(lowerName: string): Node[];
  /**
   * Direct supertypes of the type named `typeName` (same language): the classes