Factor out function for querying document symbols for URI

Author: fwcd

Sources/SourceKitLSP/Swift/SwiftLanguageServer.swift

@@ -507,86 +507,105 @@ extension SwiftLanguageServer {
     }
   }
 
-  public func documentSymbol(_ req: Request<DocumentSymbolRequest>) {
-    let keys = self.keys
+  // Must be called on self.queue
+  private func _documentSymbols(
+    _ uri: DocumentURI,
+    _ completion: @escaping (Result<[DocumentSymbol], ResponseError>) -> Void
+  ) {
+    if #available(macOS 10.12, *) {
+      dispatchPrecondition(condition: .onQueue(queue))
+    }
 
-    queue.async {
-      guard let snapshot = self.documentManager.latestSnapshot(req.params.textDocument.uri) else {
-        log("failed to find snapshot for url \(req.params.textDocument.uri)")
-        req.reply(nil)
-        return
+    guard let snapshot = self.documentManager.latestSnapshot(uri) else {
+      let msg = "failed to find snapshot for url \(uri)"
+      log(msg)
+      return completion(.failure(.unknown(msg)))
+    }
+
+    let skreq = SKDRequestDictionary(sourcekitd: self.sourcekitd)
+    skreq[keys.request] = self.requests.editor_open
+    skreq[keys.name] = "DocumentSymbols:" + snapshot.document.uri.pseudoPath
+    skreq[keys.sourcetext] = snapshot.text
+    skreq[keys.syntactic_only] = 1
+
+    let handle = self.sourcekitd.send(skreq, self.queue) { [weak self] result in
+      guard let self = self else { return }
+      guard let dict = result.success else {
+        return completion(.failure(ResponseError(result.failure!)))
+      }
+      guard let results: SKDResponseArray = dict[self.keys.substructure] else {
+        return completion(.success([]))
       }
 
-      let skreq = SKDRequestDictionary(sourcekitd: self.sourcekitd)
-      skreq[keys.request] = self.requests.editor_open
-      skreq[keys.name] = "DocumentSymbols:" + snapshot.document.uri.pseudoPath
-      skreq[keys.sourcetext] = snapshot.text
-      skreq[keys.syntactic_only] = 1
+      func documentSymbol(value: SKDResponseDictionary) -> DocumentSymbol? {
+        guard let name: String = value[self.keys.name],
+              let uid: sourcekitd_uid_t = value[self.keys.kind],
+              let kind: SymbolKind = uid.asSymbolKind(self.values),
+              let offset: Int = value[self.keys.offset],
+              let start: Position = snapshot.positionOf(utf8Offset: offset),
+              let length: Int = value[self.keys.length],
+              let end: Position = snapshot.positionOf(utf8Offset: offset + length) else {
+          return nil
+        }
 
-      let handle = self.sourcekitd.send(skreq, self.queue) { [weak self] result in
-        guard let self = self else { return }
-        guard let dict = result.success else {
-          req.reply(.failure(ResponseError(result.failure!)))
-          return
+        let range = start..<end
+        let selectionRange: Range<Position>
+        if let nameOffset: Int = value[self.keys.nameoffset],
+            let nameStart: Position = snapshot.positionOf(utf8Offset: nameOffset),
+            let nameLength: Int = value[self.keys.namelength],
+            let nameEnd: Position = snapshot.positionOf(utf8Offset: nameOffset + nameLength) {
+          selectionRange = nameStart..<nameEnd
+        } else {
+          selectionRange = range
         }
-        guard let results: SKDResponseArray = dict[self.keys.substructure] else {
-          return req.reply(.documentSymbols([]))
+
+        let children: [DocumentSymbol]?
+        if let substructure: SKDResponseArray = value[self.keys.substructure] {
+          children = documentSymbols(array: substructure)
+        } else {
+          children = nil
         }
+        return DocumentSymbol(name: name,
+                              detail: nil,
+                              kind: kind,
+                              deprecated: nil,
+                              range: range,
+                              selectionRange: selectionRange,
+                              children: children)
+      }
 
-        func documentSymbol(value: SKDResponseDictionary) -> DocumentSymbol? {
-          guard let name: String = value[self.keys.name],
-                let uid: sourcekitd_uid_t = value[self.keys.kind],
-                let kind: SymbolKind = uid.asSymbolKind(self.values),
-                let offset: Int = value[self.keys.offset],
-                let start: Position = snapshot.positionOf(utf8Offset: offset),
-                let length: Int = value[self.keys.length],
-                let end: Position = snapshot.positionOf(utf8Offset: offset + length) else {
-            return nil
+      func documentSymbols(array: SKDResponseArray) -> [DocumentSymbol] {
+        var result: [DocumentSymbol] = []
+        array.forEach { (i: Int, value: SKDResponseDictionary) in
+          if let documentSymbol = documentSymbol(value: value) {
+            result.append(documentSymbol)
+          } else if let substructure: SKDResponseArray = value[self.keys.substructure] {
+            result += documentSymbols(array: substructure)
           }
+          return true
+        }
+        return result
+      }
 
-          let range = start..<end
-          let selectionRange: Range<Position>
-          if let nameOffset: Int = value[self.keys.nameoffset],
-             let nameStart: Position = snapshot.positionOf(utf8Offset: nameOffset),
-             let nameLength: Int = value[self.keys.namelength],
-             let nameEnd: Position = snapshot.positionOf(utf8Offset: nameOffset + nameLength) {
-            selectionRange = nameStart..<nameEnd
-          } else {
-            selectionRange = range
-          }
+      completion(.success(documentSymbols(array: results)))
+    }
 
-          let children: [DocumentSymbol]?
-          if let substructure: SKDResponseArray = value[self.keys.substructure] {
-            children = documentSymbols(array: substructure)
-          } else {
-            children = nil
-          }
-          return DocumentSymbol(name: name,
-                                detail: nil,
-                                kind: kind,
-                                deprecated: nil,
-                                range: range,
-                                selectionRange: selectionRange,
-                                children: children)
-        }
+    // FIXME: cancellation
+    _ = handle
+  }
 
-        func documentSymbols(array: SKDResponseArray) -> [DocumentSymbol] {
-          var result: [DocumentSymbol] = []
-          array.forEach { (i: Int, value: SKDResponseDictionary) in
-            if let documentSymbol = documentSymbol(value: value) {
-              result.append(documentSymbol)
-            } else if let substructure: SKDResponseArray = value[self.keys.substructure] {
-              result += documentSymbols(array: substructure)
-            }
-            return true
-          }
-          return result
-        }
+  public func documentSymbols(
+    _ uri: DocumentURI,
+    _ completion: @escaping (Result<[DocumentSymbol], ResponseError>) -> Void
+  ) {
+    queue.async {
+      self._documentSymbols(uri, completion)
+    }
+  }
 
-        req.reply(.documentSymbols(documentSymbols(array: results)))
-      }
-      // FIXME: cancellation
-      _ = handle
+  public func documentSymbol(_ req: Request<DocumentSymbolRequest>) {
+    documentSymbols(req.params.textDocument.uri) { result in
+      req.reply(result.map { .documentSymbols($0) })
     }
   }