add type hierarchy from LSP 3.17

Signed-off-by: Adam Tao <[email protected]>

Author: tcx4c70

src/LanguageServerProtocol.fs

@@ -230,6 +230,9 @@ module Server =
       "textDocument/prepareCallHierarchy", requestHandling(fun s p -> s.TextDocumentPrepareCallHierarchy(p))
       "callHierarchy/incomingCalls", requestHandling(fun s p -> s.CallHierarchyIncomingCalls(p))
       "callHierarchy/outgoingCalls", requestHandling(fun s p -> s.CallHierarchyOutgoingCalls(p))
+      "textDocument/prepareTypeHierarchy", requestHandling(fun s p -> s.TextDocumentPrepareTypeHierarchy(p))
+      "typeHierarchy/supertypes", requestHandling(fun s p -> s.TypeHierarchySupertypes(p))
+      "typeHierarchy/subtypes", requestHandling(fun s p -> s.TypeHierarchySubtypes(p))
       "textDocument/semanticTokens/full", requestHandling (fun s p -> s.TextDocumentSemanticTokensFull(p))
       "textDocument/semanticTokens/full/delta", requestHandling (fun s p -> s.TextDocumentSemanticTokensFullDelta(p))
       "textDocument/semanticTokens/range", requestHandling (fun s p -> s.TextDocumentSemanticTokensRange(p))

src/Server.fs

@@ -327,6 +327,25 @@ type ILspServer =
   /// registers for the `textDocument/prepareCallHierarchy` request.
   abstract member CallHierarchyOutgoingCalls: CallHierarchyOutgoingCallsParams -> AsyncLspResult<CallHierarchyOutgoingCall [] option>
 
+  /// The type hierarchy request is sent from the client to the server to return a type hierarchy for the
+  /// language element of given text document positions. Will return `null` if the server couldn't infer a
+  /// valid type from the position. The type hierarchy requests are executed in two steps:
+  /// 1. first a type hierarchy item is prepared for the given text document position.
+  /// 2. for a type hierarchy item the supertype or subtype type hierarchy items are resolved.
+  abstract member TextDocumentPrepareTypeHierarchy: TypeHierarchyPrepareParams -> AsyncLspResult<TypeHierarchyItem [] option>
+
+  /// The request is sent from the client to the server to resolve the supertype for a given type hierarchy
+  /// item. Will return `null` is the serve couldn't infer a valid type from `item` in the params. The request
+  /// doesn't defines its own client and server capabilities. It is only issued if a server registers for the
+  /// `textDocument/prepareTypeHierarchy` request.
+  abstract member TypeHierarchySupertypes: TypeHierarchySupertypesParams -> AsyncLspResult<TypeHierarchyItem [] option>
+
+  /// The request is sent from the client to the server to resolve the supertype for a given type hierarchy
+  /// item. Will return `null` is the serve couldn't infer a valid type from `item` in the params. The request
+  /// doesn't defines its own client and server capabilities. It is only issued if a server registers for the
+  /// `textDocument/prepareTypeHierarchy` request.
+  abstract member TypeHierarchySubtypes: TypeHierarchySubtypesParams -> AsyncLspResult<TypeHierarchyItem [] option>
+
 [<AbstractClass>]
 type LspServer() =
   abstract member Dispose: unit -> unit
@@ -706,6 +725,28 @@ type LspServer() =
   abstract member CallHierarchyOutgoingCalls: CallHierarchyOutgoingCallsParams -> AsyncLspResult<CallHierarchyOutgoingCall [] option>
   default __.CallHierarchyOutgoingCalls(_) = notImplemented
 
+  /// The type hierarchy request is sent from the client to the server to return a type hierarchy for the
+  /// language element of given text document positions. Will return `null` if the server couldn't infer a
+  /// valid type from the position. The type hierarchy requests are executed in two steps:
+  /// 1. first a type hierarchy item is prepared for the given text document position.
+  /// 2. for a type hierarchy item the supertype or subtype type hierarchy items are resolved.
+  abstract member TextDocumentPrepareTypeHierarchy: TypeHierarchyPrepareParams -> AsyncLspResult<TypeHierarchyItem [] option>
+  default __.TextDocumentPrepareTypeHierarchy(_) = notImplemented
+
+  /// The request is sent from the client to the server to resolve the supertype for a given type hierarchy
+  /// item. Will return `null` is the serve couldn't infer a valid type from `item` in the params. The request
+  /// doesn't defines its own client and server capabilities. It is only issued if a server registers for the
+  /// `textDocument/prepareTypeHierarchy` request.
+  abstract member TypeHierarchySupertypes: TypeHierarchySupertypesParams -> AsyncLspResult<TypeHierarchyItem [] option>
+  default __.TypeHierarchySupertypes(_) = notImplemented
+
+  /// The request is sent from the client to the server to resolve the supertype for a given type hierarchy
+  /// item. Will return `null` is the serve couldn't infer a valid type from `item` in the params. The request
+  /// doesn't defines its own client and server capabilities. It is only issued if a server registers for the
+  /// `textDocument/prepareTypeHierarchy` request.
+  abstract member TypeHierarchySubtypes: TypeHierarchySubtypesParams -> AsyncLspResult<TypeHierarchyItem [] option>
+  default __.TypeHierarchySubtypes(_) = notImplemented
+
   interface ILspServer with
     member this.Dispose() = this.Dispose()
     member this.Initialize(p: InitializeParams) = this.Initialize(p)
@@ -773,3 +814,7 @@ type LspServer() =
     member this.TextDocumentPrepareCallHierarchy(p: CallHierarchyPrepareParams) = this.TextDocumentPrepareCallHierarchy(p)
     member this.CallHierarchyIncomingCalls(p: CallHierarchyIncomingCallsParams) = this.CallHierarchyIncomingCalls(p)
     member this.CallHierarchyOutgoingCalls(p: CallHierarchyOutgoingCallsParams) = this.CallHierarchyOutgoingCalls(p)
+
+    member this.TextDocumentPrepareTypeHierarchy(p: TypeHierarchyPrepareParams) = this.TextDocumentPrepareTypeHierarchy(p)
+    member this.TypeHierarchySupertypes(p: TypeHierarchySupertypesParams) = this.TypeHierarchySupertypes(p)
+    member this.TypeHierarchySubtypes(p: TypeHierarchySubtypesParams) = this.TypeHierarchySubtypes(p)

src/Types.fs

@@ -836,6 +836,11 @@ type TextDocumentClientCapabilities =
     /// @since 3.16.0
     SemanticTokens: SemanticTokensClientCapabilities option
 
+    /// Capabilities specific to the various type hierarchy requests.
+    ///
+    /// @since 3.17.0
+    TypeHierarchy: DynamicCapabilities option
+
     /// Capabilities specific to the `textDocument/inlayHint` request.
     ///
     /// @since 3.17.0
@@ -1185,6 +1190,8 @@ type ServerCapabilities =
 
     SemanticTokensProvider: SemanticTokensOptions option
 
+    TypeHierarchyProvider: bool option
+
     InlayHintProvider: InlayHintOptions option
 
     InlineValueProvider: InlineValueOptions option
@@ -1218,6 +1225,7 @@ type ServerCapabilities =
       SelectionRangeProvider = None
       CallHierarchyProvider = None
       SemanticTokensProvider = None
+      TypeHierarchyProvider = None
       InlayHintProvider = None 
       InlineValueProvider = None
       Workspace = None }
@@ -2264,6 +2272,18 @@ type CallHierarchyOutgoingCall =
     /// request.
     FromRanges: Range[] }
 
+type TypeHierarchyPrepareParams =
+  { TextDocument: TextDocumentIdentifier
+
+    /// The position at which this request was sent.
+    Position: Position }
+
+type TypeHierarchyItem = HierarchyItem
+
+type TypeHierarchySupertypesParams = { Item: TypeHierarchyItem }
+
+type TypeHierarchySubtypesParams = { Item: TypeHierarchyItem }
+
 type SemanticTokensParams = { TextDocument: TextDocumentIdentifier }
 
 type SemanticTokensDeltaParams =

tests/Benchmarks.fs

@@ -464,6 +464,7 @@ type MultipleTypesBenchmarks() =
                         Formats = [| TokenFormat.Relative |]
                         OverlappingTokenSupport = Some false
                         MultilineTokenSupport = Some true }
+                  TypeHierarchy = Some { DynamicRegistration = None }
                   InlayHint =
                     Some
                       { DynamicRegistration = Some true