add inlineValue from LSP 3.17

Author: kaashyapan

src/LanguageServerProtocol.fs

@@ -232,6 +232,7 @@ module Server =
       "textDocument/semanticTokens/range", requestHandling (fun s p -> s.TextDocumentSemanticTokensRange(p))
       "textDocument/inlayHint", requestHandling (fun s p -> s.TextDocumentInlayHint(p))
       "inlayHint/resolve", requestHandling (fun s p -> s.InlayHintResolve(p))
+      "textDocument/inlineValue", requestHandling (fun s p -> s.TextDocumentInlineValue(p))
       "workspace/didChangeWatchedFiles",
       requestHandling (fun s p -> s.WorkspaceDidChangeWatchedFiles(p) |> notificationSuccess)
       "workspace/didChangeWorkspaceFolders",

src/Server.fs

@@ -306,6 +306,10 @@ type ILspServer =
   /// reasons: in case of error, reloading a workspace etc.
   abstract member WorkDoneProgessCancel: ProgressToken -> Async<unit>
 
+  /// The inline value request is sent from the client to the server to compute inline values for a given text document 
+  /// that may be rendered in the editor at the end of lines.
+  abstract member TextDocumentInlineValue: InlineValueParams -> AsyncLspResult<InlineValue [] option>
+
 [<AbstractClass>]
 type LspServer() =
   abstract member Dispose: unit -> unit
@@ -660,6 +664,11 @@ type LspServer() =
 
   default __.WorkDoneProgessCancel(_) = ignoreNotification
 
+  /// The inline value request is sent from the client to the server to compute inline values for a given text document 
+  /// that may be rendered in the editor at the end of lines.
+  abstract member TextDocumentInlineValue: InlineValueParams -> AsyncLspResult<InlineValue [] option>
+  default __.TextDocumentInlineValue(_) = notImplemented
+
   interface ILspServer with
     member this.Dispose() = this.Dispose()
     member this.Initialize(p: InitializeParams) = this.Initialize(p)
@@ -721,4 +730,5 @@ type LspServer() =
     member this.TextDocumentSemanticTokensRange(p: SemanticTokensRangeParams) = this.TextDocumentSemanticTokensRange(p)
     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.WorkDoneProgessCancel(token) = this.WorkDoneProgessCancel(token)
+    member this.TextDocumentInlineValue(p: InlineValueParams) = this.TextDocumentInlineValue(p)

src/Types.fs

@@ -333,6 +333,17 @@ type InlayHintWorkspaceClientCapabilities =
     /// change that requires such a calculation.
     RefreshSupport: bool option }
 
+/// Client workspace capabilities specific to inline values.
+type InlineValueWorkspaceClientCapabilities =
+  { /// Whether the client implementation supports a refresh request sent from
+    /// the server to the client.
+    ///
+    /// Note that this event is global and will force the client to refresh all
+    /// inline values currently shown. It should be used with absolute care and
+    /// is useful for situation where a server for example detects a project wide
+    /// change that requires such a calculation.
+    RefreshSupport: bool option }
+
 type CodeLensWorkspaceClientCapabilities =
   { /// Whether the client implementation supports a refresh request sent from the
     /// server to the client.
@@ -372,6 +383,12 @@ type WorkspaceClientCapabilities =
     /// @since 3.17.0
     InlayHint: InlayHintWorkspaceClientCapabilities option
 
+
+    /// Client workspace capabilities specific to inline value.
+    ///
+    /// @since 3.17.0
+    InlineValue: InlineValueWorkspaceClientCapabilities option
+
     /// Client workspace capabilities specific to code lenses.
     ///
     /// @since 3.16.0
@@ -726,6 +743,19 @@ type InlayHintClientCapabilities =
     /// hint.
     ResolveSupport: InlayHintClientCapabilitiesResolveSupport option }
 
+
+type InlineValueClientCapabilitiesResolveSupport =
+  { /// The properties that a client can resolve lazily.
+    Properties: string [] }
+
+/// Inline value client capabilities.
+type InlineValueClientCapabilities =
+  { /// Whether inline value support dynamic registration.
+    DynamicRegistration: bool option
+    /// Indicates which properties a client can resolve lazily on a inline
+    /// value.
+    ResolveSupport: InlineValueClientCapabilitiesResolveSupport option }
+
 type RenameClientCapabilities =
   { /// Whether rename supports dynamic registration.
     DynamicRegistration: bool option
@@ -1005,6 +1035,10 @@ type InlayHintOptions =
   { /// The server provides support to resolve additional information for an inlay hint item.
     ResolveProvider: bool option }
 
+type InlineValueOptions =
+  { /// The server provides support to resolve additional information for aniline lay hint item.
+    ResolveProvider: bool option }
+
 type WorkspaceFoldersServerCapabilities =
   { /// The server has support for workspace folders.
     Supported: bool option
@@ -1143,6 +1177,8 @@ type ServerCapabilities =
 
     InlayHintProvider: InlayHintOptions option
 
+    InlineValueProvider: InlineValueOptions option
+
     /// Workspace specific server capabilities.
     Workspace: WorkspaceServerCapabilities option
 
@@ -1171,7 +1207,8 @@ type ServerCapabilities =
       FoldingRangeProvider = None
       SelectionRangeProvider = None
       SemanticTokensProvider = None
-      InlayHintProvider = None
+      InlayHintProvider = None 
+      InlineValueProvider = None
       Workspace = None }
 
 type InitializeResult =
@@ -2330,6 +2367,40 @@ type InlayHint =
     /// a `textDocument/inlayHint` and a `inlayHint/resolve` request.
     Data: LSPAny option }
 
+/// InlineValue Context
+type InlineValueContext =
+    {
+        /// The stack frame (as a DAP Id) where the execution has stopped.
+        FrameId: int
+
+        /// The document range where execution has stopped.
+        /// Typically the end position of the range denotes the line where the inline values are shown.
+        StoppedLocation: Range }
+
+/// A parameter literal used in inline value requests.
+type InlineValueParams = (*WorkDoneProgressParams &*)
+  { /// The text document.
+    TextDocument: TextDocumentIdentifier
+    /// The visible document range for which inline values should be computed.
+    Range: Range 
+    /// Additional information about the context in which inline values were requested
+    Context: InlineValueContext }
+
+/// Provide inline value as text.
+type InlineValueText = 
+    {
+        /// The document range for which the inline value applies.
+        Range: Range
+        /// The text of the inline value.
+        Text: String
+    }
+
+[<ErasedUnion>]
+[<RequireQualifiedAccess>]  
+type InlineValue =
+  | InlineValueText of InlineValueText
+
+
 type ProgressToken = U2<int, string>
 
 type WorkDoneProgressCreateParams =

tests/Benchmarks.fs

@@ -402,6 +402,7 @@ type MultipleTypesBenchmarks() =
                         SymbolKind = Some { ValueSet = Some SymbolKindCapabilities.DefaultValueSet } }
                   SemanticTokens = Some { RefreshSupport = Some true }
                   InlayHint = Some { RefreshSupport = Some false }
+                  InlineValue = Some { RefreshSupport = Some false }
                   CodeLens = Some { RefreshSupport = Some true } }
             TextDocument =
               Some

tests/Tests.fs

@@ -843,6 +843,22 @@ let private serializationTests =
 
                testThereAndBackAgain theInlayHint ]
 
+      testList
+        (nameof InlineValue)
+        [
+          // Life of InlineValue:
+          // * output of `textDocument/inlineValue` (`InlineValue[]`)
+          // -> must be serializable as well as deserializable
+          testCase "can roundtrip InlineValue with all fields (simple)"
+          <| fun _ ->
+               let theInlineValue: InlineValue =
+                  { InlineValueText.Range = { Start = { Line = 5; Character = 7 }; End = { Line = 5; Character = 10 } } 
+                    Text = "test" }
+                  |> InlineValue.InlineValueText 
+
+               testThereAndBackAgain theInlineValue ]
+
+       
       Shotgun.tests ]
 
 [<Tests>]