Method createContext

src/resolution/index.ts:433–692

* Create the resolution context

()

   * Create the resolution context
   */
  private createContext(): ResolutionContext {
    return {
      getNodesInFile: (filePath: string) => {
        if (!this.nodeCache.has(filePath)) {
          this.nodeCache.set(filePath, this.queries.getNodesByFile(filePath));
        }
        return this.nodeCache.get(filePath)!;
      },

      getNodesByName: (name: string) => {
        const cached = this.nameCache.get(name);
        if (cached !== undefined) return cached;
        const result = this.queries.getNodesByName(name);
        this.nameCache.set(name, result);
        return result;
      },

      getMethodMatches: (typeName: string, methodName: string, language: Language) => {
        const key = `${language} ${typeName}::${methodName}`;
        const cached = this.methodMatchCache.get(key);
        if (cached !== undefined) return cached;
        let candidates = this.nameCache.get(methodName);
        if (candidates === undefined) {
          candidates = this.queries.getNodesByName(methodName);
          this.nameCache.set(methodName, candidates);
        }
        const want = `${typeName}::${methodName}`;
        let matches: Node[];
        if (typeName.includes('::') || methodName.includes(':')) {
          // Legacy linear filter for the shapes the owner index below can't
          // key exactly: a multi-segment typeName (the endsWith test then
          // spans more than two `::` segments) and ObjC selectors (whose
          // single/empty-keyword colons defeat the segment split). Tiny
          // populations; the per-key memo above still amortizes them.
          matches = [];
          for (const m of candidates) {
            if (m.kind !== 'method') continue;
            if (m.language !== language) continue;
            const qn = m.qualifiedName;
            if (qn === want || qn.endsWith(`::${want}`)) matches.push(m);
          }
        } else {
          // Owner index: the linear filter above is O(all same-named methods)
          // per CACHE MISS, and on overload-heavy landscapes the distinct
          // (type, method) key space is so large the per-key memo never
          // amortizes — Swift's `init` has tens of thousands of candidates
          // and the compiler repo measured 732µs per failing call, most of it
          // this scan (re-entered once per supertype recursion level, too).
          // Bucket each (language, methodName)'s candidates ONCE by the
          // qualifiedName's last two `::` segments — exactly the span the
          // `qn === want || qn.endsWith('::' + want)` predicate tests for a
          // segment-clean typeName — then every query is a map lookup.
          // Bucket insertion follows candidate order, so each bucket is
          // byte-identical to what the linear filter produced.
          const idxKey = `${language} ${methodName}`;
          let ownerIndex = this.methodOwnerIndexCache.get(idxKey);
          if (!ownerIndex) {
            ownerIndex = new Map<string, Node[]>();