add call hierarchy from LSP 3.16

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

Author: tcx4c70

src/LanguageServerProtocol.fs

@@ -227,6 +227,9 @@ module Server =
       "textDocument/documentSymbol", requestHandling (fun s p -> s.TextDocumentDocumentSymbol(p))
       "textDocument/foldingRange", requestHandling (fun s p -> s.TextDocumentFoldingRange(p))
       "textDocument/selectionRange", requestHandling (fun s p -> s.TextDocumentSelectionRange(p))
+      "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/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

@@ -310,6 +310,23 @@ type ILspServer =
   /// that may be rendered in the editor at the end of lines.
   abstract member TextDocumentInlineValue: InlineValueParams -> AsyncLspResult<InlineValue [] option>
 
+  /// The call hierarchy request is sent from the client to the server to return a call hierarchy for the
+  /// language element of given text document positions. The call hierarchy requests are executed in two
+  /// steps:
+  /// 1. first a call hierarchy item is resolved for the given text document position
+  /// 2. for a call hierarchy item the incoming or outgoing call hierarchy items are resolved.
+  abstract member TextDocumentPrepareCallHierarchy: CallHierarchyPrepareParams -> AsyncLspResult<CallHierarchyItem [] option>
+
+  /// The request is sent from the client to the server to resolve incoming calls for a given call hierarchy
+  /// item. The request doesn't define its own client and server capabilities. It is only issued if a server
+  /// registers for the `textDocument/prepareCallHierarchy` request.
+  abstract member CallHierarchyIncomingCalls: CallHierarchyIncomingCallsParams -> AsyncLspResult<CallHierarchyIncomingCall [] option>
+
+  /// The request is sent from the client to the server to resolve outgoing calls for a given call hierarchy
+  /// item. The request doesn't define its own  client and server capabilities. It is only issued if a server
+  /// registers for the `textDocument/prepareCallHierarchy` request.
+  abstract member CallHierarchyOutgoingCalls: CallHierarchyOutgoingCallsParams -> AsyncLspResult<CallHierarchyOutgoingCall [] option>
+
 [<AbstractClass>]
 type LspServer() =
   abstract member Dispose: unit -> unit
@@ -669,6 +686,26 @@ type LspServer() =
   abstract member TextDocumentInlineValue: InlineValueParams -> AsyncLspResult<InlineValue [] option>
   default __.TextDocumentInlineValue(_) = notImplemented
 
+  /// The call hierarchy request is sent from the client to the server to return a call hierarchy for the
+  /// language element of given text document positions. The call hierarchy requests are executed in two
+  /// steps:
+  /// 1. first a call hierarchy item is resolved for the given text document position
+  /// 2. for a call hierarchy item the incoming or outgoing call hierarchy items are resolved.
+  abstract member TextDocumentPrepareCallHierarchy: CallHierarchyPrepareParams -> AsyncLspResult<CallHierarchyItem [] option>
+  default __.TextDocumentPrepareCallHierarchy(_) = notImplemented
+
+  /// The request is sent from the client to the server to resolve incoming calls for a given call hierarchy
+  /// item. The request doesn't define its own client and server capabilities. It is only issued if a server
+  /// registers for the `textDocument/prepareCallHierarchy` request.
+  abstract member CallHierarchyIncomingCalls: CallHierarchyIncomingCallsParams -> AsyncLspResult<CallHierarchyIncomingCall [] option>
+  default __.CallHierarchyIncomingCalls(_) = notImplemented
+
+  /// The request is sent from the client to the server to resolve outgoing calls for a given call hierarchy
+  /// item. The request doesn't define its own  client and server capabilities. It is only issued if a server
+  /// registers for the `textDocument/prepareCallHierarchy` request.
+  abstract member CallHierarchyOutgoingCalls: CallHierarchyOutgoingCallsParams -> AsyncLspResult<CallHierarchyOutgoingCall [] option>
+  default __.CallHierarchyOutgoingCalls(_) = notImplemented
+
   interface ILspServer with
     member this.Dispose() = this.Dispose()
     member this.Initialize(p: InitializeParams) = this.Initialize(p)
@@ -731,4 +768,8 @@ type LspServer() =
     member this.TextDocumentInlayHint(p: InlayHintParams) = this.TextDocumentInlayHint(p)
     member this.InlayHintResolve(p: InlayHint) = this.InlayHintResolve(p)
     member this.WorkDoneProgessCancel(token) = this.WorkDoneProgessCancel(token)
-    member this.TextDocumentInlineValue(p: InlineValueParams) = this.TextDocumentInlineValue(p)
+    member this.TextDocumentInlineValue(p: InlineValueParams) = this.TextDocumentInlineValue(p)
+
+    member this.TextDocumentPrepareCallHierarchy(p: CallHierarchyPrepareParams) = this.TextDocumentPrepareCallHierarchy(p)
+    member this.CallHierarchyIncomingCalls(p: CallHierarchyIncomingCallsParams) = this.CallHierarchyIncomingCalls(p)
+    member this.CallHierarchyOutgoingCalls(p: CallHierarchyOutgoingCallsParams) = this.CallHierarchyOutgoingCalls(p)

src/Types.fs

@@ -162,6 +162,9 @@ type SymbolKind =
   | Operator = 25
   | TypeParameter = 26
 
+type SymbolTag =
+  | Deprecated = 1
+
 /// Represents information about programming constructs like variables, classes,
 /// interfaces etc.
 type SymbolInformation =
@@ -824,6 +827,11 @@ type TextDocumentClientCapabilities =
     /// Capabilities for the `textDocument/selectionRange`
     SelectionRange: DynamicCapabilities option
 
+    /// Capabilities specific to the various call hierarchy requests.
+    ///
+    /// @since 3.16.0
+    CallHierarchy: DynamicCapabilities option
+
     /// Capabilities specific to the various semantic token requests.
     /// @since 3.16.0
     SemanticTokens: SemanticTokensClientCapabilities option
@@ -1173,6 +1181,8 @@ type ServerCapabilities =
 
     SelectionRangeProvider: bool option
 
+    CallHierarchyProvider: bool option
+
     SemanticTokensProvider: SemanticTokensOptions option
 
     InlayHintProvider: InlayHintOptions option
@@ -1206,6 +1216,7 @@ type ServerCapabilities =
       Experimental = None
       FoldingRangeProvider = None
       SelectionRangeProvider = None
+      CallHierarchyProvider = None
       SemanticTokensProvider = None
       InlayHintProvider = None 
       InlineValueProvider = None
@@ -2196,6 +2207,63 @@ type SelectionRange =
     /// The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
     Parent: SelectionRange option }
 
+type CallHierarchyPrepareParams =
+  { TextDocument: TextDocumentIdentifier
+
+    /// The position at which this request was sent.
+    Position: Position }
+
+type HierarchyItem =
+  { /// The name of this item.
+    Name: string
+
+    /// The kind of this item.
+    Kind: SymbolKind
+
+    /// Tags for this item.
+    Tags: SymbolTag [] option
+
+    /// More detail for this item, e.g., the signature of a function.
+    Detail: string option
+
+    /// The resource identifier of this item.
+    Uri: DocumentUri
+
+    /// The range enclosing this symbol not including leading/trailing
+    /// whitespace but everything else, e.g., comments and code.
+    Range: Range
+
+    /// 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`].
+    SelectionRange: Range
+
+    /// A data entry field that is preserved between a call hierarchy prepare
+    /// and incoming calls or outgoing calls requests.
+    Data: JToken option }
+
+type CallHierarchyItem = HierarchyItem
+
+type CallHierarchyIncomingCallsParams = { Item: CallHierarchyItem }
+
+type CallHierarchyIncomingCall =
+  { /// The item that makes the call.
+    From: CallHierarchyItem
+
+    /// The ranges at which the calls appear. This is relative to the caller
+    /// denoted by [`this.From`].
+    FromRanges: Range [] }
+
+type CallHierarchyOutgoingCallsParams = { Item: CallHierarchyItem }
+
+type CallHierarchyOutgoingCall =
+  { /// The item that is called
+    To: CallHierarchyItem
+
+    /// The range at which this item is called. This is the range relative to
+    /// the caller, e.g., the item passed to `callHierarchy/outgoingCalls`
+    /// request.
+    FromRanges: Range[] }
+
 type SemanticTokensParams = { TextDocument: TextDocumentIdentifier }
 
 type SemanticTokensDeltaParams =

tests/Benchmarks.fs

@@ -450,6 +450,7 @@ type MultipleTypesBenchmarks() =
                         LineFoldingOnly = Some true
                         RangeLimit = None }
                   SelectionRange = Some { DynamicRegistration = None }
+                  CallHierarchy = Some { DynamicRegistration = None }
                   SemanticTokens =
                     Some
                       { DynamicRegistration = Some false

tests/Tests.fs

@@ -858,7 +858,22 @@ let private serializationTests =
 
                testThereAndBackAgain theInlineValue ]
 
-       
+      testList
+        (nameof HierarchyItem)
+        [
+          testCase "can roundtrip HierarchyItem with all fields (simple)"
+          <| fun _ ->
+               let item: HierarchyItem =
+                  { Name = "test"
+                    Kind = SymbolKind.Function 
+                    Tags = None
+                    Detail = None
+                    Uri = "..."
+                    Range = mkRange' (1, 2) (3, 4)
+                    SelectionRange = mkRange' (1, 2) (1, 4)
+                    Data = None }
+               testThereAndBackAgain item
+        ]
       Shotgun.tests ]
 
 [<Tests>]