fix: use exported function instead of class method

Author: ayame113

lib/adapters/call-hierarchy-adapter.ts

@@ -8,97 +8,90 @@ import type { Point, TextEditor } from "atom"
 
 import OutlineViewAdapter from "./outline-view-adapter"
 
-/** Public: Adapts the documentSymbolProvider of the language server to the Outline View supplied by Atom IDE UI. */
-export default class CallHierarchyAdapter {
-  private _cancellationTokens = new WeakMap<LanguageClientConnection, CancellationTokenSource>()
+const cancellationTokens = new WeakMap<LanguageClientConnection, CancellationTokenSource>()
 
-  /**
-   * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities
-   * matrix containing a callHierarchyProvider.
-   *
-   * @param serverCapabilities The {ServerCapabilities} of the language server to consider.
-   * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.
-   */
-  public static canAdapt(serverCapabilities: ServerCapabilities): boolean {
-    return Boolean(serverCapabilities.callHierarchyProvider)
-  }
-
-  /** Corresponds to lsp's CallHierarchyPrepareRequest */
+/**
+ * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities matrix
+ * containing a callHierarchyProvider.
+ *
+ * @param serverCapabilities The {ServerCapabilities} of the language server to consider.
+ * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.
+ */
+export function canAdapt(serverCapabilities: ServerCapabilities): boolean {
+  return Boolean(serverCapabilities.callHierarchyProvider)
+}
 
-  /**
-   * Public: Obtain the relationship between calling and called functions hierarchically. Corresponds to lsp's
-   * CallHierarchyPrepareRequest.
-   *
-   * @param connection A {LanguageClientConnection} to the language server that provides highlights.
-   * @param editor The Atom {TextEditor} containing the text associated with the calling.
-   * @param position The Atom {Point} associated with the calling.
-   * @param type The hierarchy type either incoming or outgoing.
-   * @returns A {Promise} of an {CallHierarchy}.
-   */
-  async getCallHierarchy<T extends atomIde.CallHierarchyType>(
-    connection: LanguageClientConnection,
-    editor: TextEditor,
-    point: Point,
-    type: T
-  ): Promise<atomIde.CallHierarchy<T>> {
-    const results = await Utils.doWithCancellationToken(connection, this._cancellationTokens, (cancellationToken) =>
-      connection.prepareCallHierarchy(
-        {
-          textDocument: Convert.editorToTextDocumentIdentifier(editor),
-          position: Convert.pointToPosition(point),
-        },
-        cancellationToken
-      )
-    )
-    return <CallHierarchyForAdapter<T>>{
-      type,
-      data: results?.map(convertCallHierarchyItem) ?? [],
-      itemAt(num: number) {
-        if (type === "incoming") {
-          return <Promise<atomIde.CallHierarchy<T>>>this.adapter.getIncoming(this.connection, this.data[num].rawData)
-        } else {
-          return <Promise<atomIde.CallHierarchy<T>>>this.adapter.getOutgoing(this.connection, this.data[num].rawData)
-        }
+/**
+ * Public: Obtain the relationship between calling and called functions hierarchically. Corresponds to lsp's
+ * CallHierarchyPrepareRequest.
+ *
+ * @param connection A {LanguageClientConnection} to the language server that provides highlights.
+ * @param editor The Atom {TextEditor} containing the text associated with the calling.
+ * @param position The Atom {Point} associated with the calling.
+ * @param type The hierarchy type either incoming or outgoing.
+ * @returns A {Promise} of an {CallHierarchy}.
+ */
+export async function getCallHierarchy<T extends atomIde.CallHierarchyType>(
+  connection: LanguageClientConnection,
+  editor: TextEditor,
+  point: Point,
+  type: T
+): Promise<atomIde.CallHierarchy<T>> {
+  const results = await Utils.doWithCancellationToken(connection, cancellationTokens, (cancellationToken) =>
+    connection.prepareCallHierarchy(
+      {
+        textDocument: Convert.editorToTextDocumentIdentifier(editor),
+        position: Convert.pointToPosition(point),
       },
-      connection,
-      adapter: this,
-    }
-  }
-  /** Corresponds to lsp's CallHierarchyIncomingCallsRequest. */
-  async getIncoming(
-    connection: LanguageClientConnection,
-    item: CallHierarchyItem
-  ): Promise<atomIde.CallHierarchy<"incoming">> {
-    const results = await Utils.doWithCancellationToken(connection, this._cancellationTokens, (_cancellationToken) =>
-      connection.callHierarchyIncomingCalls({ item })
+      cancellationToken
     )
-    return <CallHierarchyForAdapter<"incoming">>{
-      type: "incoming",
-      data: results?.map((res) => convertCallHierarchyItem(res.from)) ?? [],
-      itemAt(num: number) {
-        return this.adapter.getIncoming(this.connection, this.data[num].rawData)
-      },
-      connection,
-      adapter: this,
-    }
+  )
+  return <CallHierarchyForAdapter<T>>{
+    type,
+    data: results?.map(convertCallHierarchyItem) ?? [],
+    itemAt(num: number) {
+      if (type === "incoming") {
+        return <Promise<atomIde.CallHierarchy<T>>>getIncoming(this.connection, this.data[num].rawData)
+      } else {
+        return <Promise<atomIde.CallHierarchy<T>>>getOutgoing(this.connection, this.data[num].rawData)
+      }
+    },
+    connection,
   }
-  /** Corresponds to lsp's CallHierarchyOutgoingCallsRequest. */
-  async getOutgoing(
-    connection: LanguageClientConnection,
-    item: CallHierarchyItem
-  ): Promise<atomIde.CallHierarchy<"outgoing">> {
-    const results = await Utils.doWithCancellationToken(connection, this._cancellationTokens, (_cancellationToken) =>
-      connection.callHierarchyOutgoingCalls({ item })
-    )
-    return <CallHierarchyForAdapter<"outgoing">>{
-      type: "outgoing",
-      data: results?.map((res) => convertCallHierarchyItem(res.to)) ?? [],
-      itemAt(num: number) {
-        return this.adapter.getOutgoing(this.connection, this.data[num].rawData)
-      },
-      connection,
-      adapter: this,
-    }
+}
+
+/** Corresponds to lsp's CallHierarchyIncomingCallsRequest. */
+async function getIncoming(
+  connection: LanguageClientConnection,
+  item: CallHierarchyItem
+): Promise<atomIde.CallHierarchy<"incoming">> {
+  const results = await Utils.doWithCancellationToken(connection, cancellationTokens, (_cancellationToken) =>
+    connection.callHierarchyIncomingCalls({ item })
+  )
+  return <CallHierarchyForAdapter<"incoming">>{
+    type: "incoming",
+    data: results?.map((res) => convertCallHierarchyItem(res.from)) ?? [],
+    itemAt(num: number) {
+      return getIncoming(this.connection, this.data[num].rawData)
+    },
+    connection,
+  }
+}
+/** Corresponds to lsp's CallHierarchyOutgoingCallsRequest. */
+async function getOutgoing(
+  connection: LanguageClientConnection,
+  item: CallHierarchyItem
+): Promise<atomIde.CallHierarchy<"outgoing">> {
+  const results = await Utils.doWithCancellationToken(connection, cancellationTokens, (_cancellationToken) =>
+    connection.callHierarchyOutgoingCalls({ item })
+  )
+  return <CallHierarchyForAdapter<"outgoing">>{
+    type: "outgoing",
+    data: results?.map((res) => convertCallHierarchyItem(res.to)) ?? [],
+    itemAt(num: number) {
+      return getOutgoing(this.connection, this.data[num].rawData)
+    },
+    connection,
   }
 }
 
@@ -135,7 +128,6 @@ function symbolTagToEntityKind(symbol: number): atomIde.SymbolTagKind | null {
 /** Extend CallHierarchy to include properties used inside the adapter */
 interface CallHierarchyForAdapter<T extends atomIde.CallHierarchyType> extends atomIde.CallHierarchy<T> {
   data: CallHierarchyItemForAdapter[]
-  adapter: CallHierarchyAdapter
   connection: LanguageClientConnection
 }
 

lib/auto-languageclient.ts

@@ -8,7 +8,7 @@ import * as linter from "atom/linter"
 import Convert from "./convert.js"
 import ApplyEditAdapter from "./adapters/apply-edit-adapter"
 import AutocompleteAdapter, { grammarScopeToAutoCompleteSelector } from "./adapters/autocomplete-adapter"
-import CallHierarchyAdapter from "./adapters/call-hierarchy-adapter"
+import * as CallHierarchyAdapter from "./adapters/call-hierarchy-adapter"
 import CodeActionAdapter from "./adapters/code-action-adapter"
 import CodeFormatAdapter from "./adapters/code-format-adapter"
 import CodeHighlightAdapter from "./adapters/code-highlight-adapter"
@@ -76,7 +76,7 @@ export default class AutoLanguageClient {
 
   // Shared adapters that can take the RPC connection as required
   protected autoComplete?: AutocompleteAdapter
-  protected callHierarchy?: CallHierarchyAdapter
+  protected callHierarchy?: typeof CallHierarchyAdapter
   protected datatip?: DatatipAdapter
   protected definitions?: DefinitionAdapter
   protected findReferences?: FindReferencesAdapter
@@ -768,7 +768,7 @@ export default class AutoLanguageClient {
     if (server === null || !CallHierarchyAdapter.canAdapt(server.capabilities)) {
       return null
     }
-    this.callHierarchy = this.callHierarchy ?? new CallHierarchyAdapter()
+    this.callHierarchy = this.callHierarchy ?? CallHierarchyAdapter
     return this.callHierarchy.getCallHierarchy(server.connection, editor, point, "incoming")
   }
 
@@ -780,7 +780,7 @@ export default class AutoLanguageClient {
     if (server === null || !CallHierarchyAdapter.canAdapt(server.capabilities)) {
       return null
     }
-    this.callHierarchy = this.callHierarchy ?? new CallHierarchyAdapter()
+    this.callHierarchy = this.callHierarchy ?? CallHierarchyAdapter
     return this.callHierarchy.getCallHierarchy(server.connection, editor, point, "outgoing")
   }