Implement document symbol request

Author: Trzyipolkostkicukru

Sources/LanguageServerProtocol/DocumentSymbol.swift

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// Request for symbols to display in the document outline.
+///
+/// This is used to provide list of all symbols in the document and display inside which 
+/// type or function the cursor is currently in.
+///
+/// Servers that provide document highlights should set the `documentSymbolProvider` server
+/// capability.
+///
+/// - Parameters:
+///   - textDocument: The document in which to lookup the symbol location.
+///
+/// - Returns: An array of document symbols, if any.
+public struct DocumentSymbolRequest: TextDocumentRequest, Hashable {
+  public static let method: String = "textDocument/documentSymbol"
+  public typealias Response = [DocumentSymbol]?
+
+  /// The document in which to lookup the symbol location.
+  public var textDocument: TextDocumentIdentifier
+
+  public init(textDocument: TextDocumentIdentifier) {
+    self.textDocument = textDocument
+  }
+}
+
+/// Represents programming constructs like variables, classes, interfaces etc. that appear 
+/// in a document. Document symbols can be hierarchical and they have two ranges: one that encloses
+/// its definition and one that points to its most interesting range, e.g. the range of an identifier.
+public struct DocumentSymbol: Hashable, Codable, ResponseType {
+  
+  /// The name of this symbol. Will be displayed in the user interface and therefore must not be
+  /// an empty string or a string only consisting of white spaces.
+  var name: String
+
+  /// More detail for this symbol, e.g the signature of a function.
+  var detail: String?
+
+  /// The kind of this symbol.
+  var kind: SymbolKind
+
+  /// Indicates if this symbol is deprecated.
+  var deprecated: Bool?
+
+  /// The range enclosing this symbol not including leading/trailing whitespace but everything else
+  /// like comments. This information is typically used to determine if the clients cursor is
+  /// inside the symbol to reveal in the symbol in the UI.
+  var range: PositionRange
+
+  /// The range that should be selected and revealed when this symbol is being picked, 
+  /// e.g the name of a function.
+  ///
+  /// Must be contained by the `range`.
+  var selectionRange: PositionRange
+
+  /// Children of this symbol, e.g. properties of a class.
+  var children: [DocumentSymbol]?
+
+  public init(
+    name: String,
+    detail: String?, 
+    kind: SymbolKind,
+    deprecated: Bool?,
+    range: PositionRange,
+    selectionRange: PositionRange,
+    children: [DocumentSymbol]?) {
+      self.name = name
+      self.detail = detail
+      self.kind = kind
+      self.deprecated = deprecated
+      self.range = range
+      self.selectionRange = selectionRange
+      self.children = children
+    }
+}

Sources/LanguageServerProtocol/Messages.swift

@@ -30,6 +30,7 @@ public let builtinRequests: [_RequestType.Type] = [
   DocumentRangeFormatting.self,
   DocumentOnTypeFormatting.self,
   FoldingRangeRequest.self,
+  DocumentSymbolRequest.self,
 
   // MARK: LSP Extension Requests
 

Sources/LanguageServerProtocol/ServerCapabilities.swift

@@ -42,6 +42,9 @@ public struct ServerCapabilities: Codable, Hashable {
   /// Whether the server provides "textDocument/foldingRange".
   public var foldingRangeProvider: Bool?
 
+  /// Whether the server provides "textDocument/documentSymbol"
+  public var documentSymbolProvider: Bool?
+
   // TODO: fill-in the rest.
 
   public init(
@@ -54,7 +57,8 @@ public struct ServerCapabilities: Codable, Hashable {
     documentFormattingProvider: Bool? = nil,
     documentRangeFormattingProvider: Bool? = nil,
     documentOnTypeFormattingProvider: DocumentOnTypeFormattingOptions? = nil,
-    foldingRangeProvider: Bool? = nil
+    foldingRangeProvider: Bool? = nil,
+    documentSymbolProvider: Bool? = nil
     )
   {
     self.textDocumentSync = textDocumentSync
@@ -67,6 +71,7 @@ public struct ServerCapabilities: Codable, Hashable {
     self.documentRangeFormattingProvider = documentRangeFormattingProvider
     self.documentOnTypeFormattingProvider = documentOnTypeFormattingProvider
     self.foldingRangeProvider = foldingRangeProvider
+    self.documentSymbolProvider = documentSymbolProvider
   }
 
   public init(from decoder: Decoder) throws {
@@ -75,6 +80,7 @@ public struct ServerCapabilities: Codable, Hashable {
     self.hoverProvider = try container.decodeIfPresent(Bool.self, forKey: .hoverProvider)
     self.definitionProvider = try container.decodeIfPresent(Bool.self, forKey: .definitionProvider)
     self.foldingRangeProvider = try container.decodeIfPresent(Bool.self, forKey: .foldingRangeProvider)
+    self.documentSymbolProvider = try container.decodeIfPresent(Bool.self, forKey: .documentSymbolProvider)
 
     if let textDocumentSync = try? container.decode(TextDocumentSyncOptions.self, forKey: .textDocumentSync) {
       self.textDocumentSync = textDocumentSync

Sources/SourceKit/SourceKitServer.swift

@@ -76,6 +76,7 @@ public final class SourceKitServer: LanguageServer {
     registerWorkspaceRequest(SourceKitServer.documentSymbolHighlight)
     registerWorkspaceRequest(SourceKitServer.foldingRange)
     registerWorkspaceRequest(SourceKitServer.symbolInfo)
+    registerWorkspaceRequest(SourceKitServer.documentSymbol)
   }
 
   func registerWorkspaceRequest<R>(
@@ -257,7 +258,8 @@ extension SourceKitServer {
       definitionProvider: true,
       referencesProvider: true,
       documentHighlightProvider: true,
-      foldingRangeProvider: true
+      foldingRangeProvider: true,
+      documentSymbolProvider: true
     )))
   }
 
@@ -339,6 +341,10 @@ extension SourceKitServer {
     toolchainTextDocumentRequest(req, workspace: workspace, fallback: nil)
   }
 
+  func documentSymbol(_ req: Request<DocumentSymbolRequest>, workspace: Workspace) {
+    toolchainTextDocumentRequest(req, workspace: workspace, fallback: nil)
+  }
+
   func definition(_ req: Request<DefinitionRequest>, workspace: Workspace) {
     // FIXME: sending yourself a request isn't very convenient
 

Sources/SourceKit/sourcekitd/SwiftLanguageServer.swift

@@ -63,6 +63,7 @@ public final class SwiftLanguageServer: LanguageServer {
     _register(SwiftLanguageServer.documentSymbolHighlight)
     _register(SwiftLanguageServer.foldingRange)
     _register(SwiftLanguageServer.symbolInfo)
+    _register(SwiftLanguageServer.documentSymbol)
   }
 
   func getDiagnostic(_ diag: SKResponseDictionary, for snapshot: DocumentSnapshot) -> Diagnostic? {
@@ -191,7 +192,8 @@ extension SwiftLanguageServer {
       definitionProvider: nil,
       referencesProvider: nil,
       documentHighlightProvider: true,
-      foldingRangeProvider: true
+      foldingRangeProvider: true,
+      documentSymbolProvider: true
       )))
   }
 
@@ -471,6 +473,117 @@ extension SwiftLanguageServer {
     }
   }
 
+  func documentSymbol(_ req: Request<DocumentSymbolRequest>) {
+    guard let snapshot = documentManager.latestSnapshot(req.params.textDocument.url) else {
+      log("failed to find snapshot for url \(req.params.textDocument.url)")
+      req.reply(nil)
+      return
+    }
+
+    let skreq = SKRequestDictionary(sourcekitd: sourcekitd)
+    skreq[keys.request] = requests.editor_open
+    skreq[keys.name] = snapshot.document.url.path
+    skreq[keys.sourcefile] = snapshot.document.url.path
+    let handle = sourcekitd.send(skreq) { [weak self] result in
+      guard let self = self else { return }
+      guard let dict = result.success else {
+        req.reply(.failure(result.failure!))
+        return
+      }
+      guard let results: SKResponseArray = dict[self.keys.substructure] else {
+        return req.reply([])
+      }
+
+      /// Translate sourcekit symbol kinds into LSP kinds.
+      func symbolKind(sourcekitSymbolKind: sourcekitd_uid_t) -> SymbolKind? {
+        switch sourcekitSymbolKind {
+          case self.values.decl_class:
+            return .class
+          case self.values.decl_function_method_instance,
+            self.values.decl_function_method_static:
+            return .method
+          case self.values.decl_var_instance:
+            return .property
+          case self.values.decl_enum:
+            return .enum
+          case self.values.decl_enumelement:
+            return .enumMember
+          case self.values.decl_protocol:
+            return .interface
+          case self.values.decl_function_free:
+            return .function
+          case self.values.decl_var_global:
+            return .variable
+          case self.values.decl_struct:
+            return .struct
+          case self.values.decl_generic_type_param:
+            return .typeParameter
+          case self.values.decl_extension:
+            // There are no extensions in LSP, so I return something vaguely similar
+            return .namespace
+          default:
+            return nil
+        }
+      }
+
+      func documentSymbol(value: SKResponseDictionary) -> DocumentSymbol? {
+        guard let name: String = value[self.keys.name],
+          let kind: SymbolKind = value[self.keys.kind].flatMap(symbolKind(sourcekitSymbolKind:)),
+          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 range = PositionRange(start..<end)
+        let selectionRange: PositionRange
+        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 = PositionRange(nameStart..<nameEnd)
+        } else {
+          selectionRange = range
+        }
+
+        let children: [DocumentSymbol]?
+        if let substructure: SKResponseArray = 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 documentSymbols(array: SKResponseArray) -> [DocumentSymbol] {
+        var result: [DocumentSymbol] = []
+        array.forEach { (i: Int, value: SKResponseDictionary) in
+          if let documentSymbol = documentSymbol(value: value) {
+            result.append(documentSymbol)
+          } else if let substructure: SKResponseArray = value[self.keys.substructure] {
+            result += documentSymbols(array: substructure)
+          }
+          return true
+        }
+        return result
+      }
+      
+      req.reply(documentSymbols(array: results))
+    }
+    // FIXME: cancellation
+    _ = handle
+    return
+  }
+
   func documentSymbolHighlight(_ req: Request<DocumentHighlightRequest>) {
 
     guard let snapshot = documentManager.latestSnapshot(req.params.textDocument.url) else {

Sources/SourceKit/sourcekitd/SwiftSourceKitFramework.swift

@@ -214,6 +214,8 @@ struct sourcekitd_keys {
   let bodyoffset: sourcekitd_uid_t
   let bodylength: sourcekitd_uid_t
   let syntaxmap: sourcekitd_uid_t
+  let namelength: sourcekitd_uid_t
+  let nameoffset: sourcekitd_uid_t
 
   init(api: sourcekitd_functions_t) {
     request = api.uid_get_from_cstr("key.request")!
@@ -242,6 +244,8 @@ struct sourcekitd_keys {
     bodyoffset = api.uid_get_from_cstr("key.bodyoffset")!
     bodylength = api.uid_get_from_cstr("key.bodylength")!
     syntaxmap = api.uid_get_from_cstr("key.syntaxmap")!
+    namelength = api.uid_get_from_cstr("key.namelength")!
+    nameoffset = api.uid_get_from_cstr("key.nameoffset")!
   }
 }