Method createContext

src/resolution/index.ts:497–796

* Create the resolution context

()

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

      fileHasExportedNode: (filePath: string) => {
        const cached = this.nodeCache.get(filePath);
        return cached !== undefined ? cached.some((n) => n.isExported) : this.queries.fileHasExportedNode(filePath);
      },

      getExportedNodesInFile: (filePath: string) => {
        const cached = this.nodeCache.get(filePath);
        return cached !== undefined ? cached.filter((n) => n.isExported) : this.queries.getExportedNodesByFile(filePath);
      },

      getNodesInFileNamed: (filePath: string, name: string) => {
        const cached = this.nodeCache.get(filePath);
        return cached !== undefined ? cached.filter((n) => n.name === name) : this.queries.getNodesByFileAndName(filePath, name);
      },

      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 (!sameLanguageFamily(m.language, language)) continue;
            const qn = m.qualifiedName;
            if (qn === want || qn.endsWith(`::${want}`)) matches.push(m);
          }
        } else {