.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/internal/lsp/protocol/tsserver.go

   1 // Copyright 2019 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package protocol
   6
   7 // Package protocol contains data types and code for LSP jsonrpcs
   8 // generated automatically from vscode-languageserver-node
   9 // commit: dae62de921d25964e8732411ca09e532dde992f5
  10 // last fetched Thu Feb 04 2021 11:11:02 GMT-0500 (Eastern Standard Time)
  11
  12 // Code generated (see typescript/README.md) DO NOT EDIT.
  13
  14 import (
  15         "context"
  16         "encoding/json"
  17
  18         "golang.org/x/tools/internal/jsonrpc2"
  19         errors "golang.org/x/xerrors"
  20 )
  21
  22 type Server interface {
  23         DidChangeWorkspaceFolders(context.Context, *DidChangeWorkspaceFoldersParams) error
  24         WorkDoneProgressCancel(context.Context, *WorkDoneProgressCancelParams) error
  25         DidCreateFiles(context.Context, *CreateFilesParams) error
  26         DidRenameFiles(context.Context, *RenameFilesParams) error
  27         DidDeleteFiles(context.Context, *DeleteFilesParams) error
  28         Initialized(context.Context, *InitializedParams) error
  29         Exit(context.Context) error
  30         DidChangeConfiguration(context.Context, *DidChangeConfigurationParams) error
  31         DidOpen(context.Context, *DidOpenTextDocumentParams) error
  32         DidChange(context.Context, *DidChangeTextDocumentParams) error
  33         DidClose(context.Context, *DidCloseTextDocumentParams) error
  34         DidSave(context.Context, *DidSaveTextDocumentParams) error
  35         WillSave(context.Context, *WillSaveTextDocumentParams) error
  36         DidChangeWatchedFiles(context.Context, *DidChangeWatchedFilesParams) error
  37         SetTrace(context.Context, *SetTraceParams) error
  38         LogTrace(context.Context, *LogTraceParams) error
  39         Implementation(context.Context, *ImplementationParams) (Definition /*Definition | DefinitionLink[] | null*/, error)
  40         TypeDefinition(context.Context, *TypeDefinitionParams) (Definition /*Definition | DefinitionLink[] | null*/, error)
  41         DocumentColor(context.Context, *DocumentColorParams) ([]ColorInformation, error)
  42         ColorPresentation(context.Context, *ColorPresentationParams) ([]ColorPresentation, error)
  43         FoldingRange(context.Context, *FoldingRangeParams) ([]FoldingRange /*FoldingRange[] | null*/, error)
  44         Declaration(context.Context, *DeclarationParams) (Declaration /*Declaration | DeclarationLink[] | null*/, error)
  45         SelectionRange(context.Context, *SelectionRangeParams) ([]SelectionRange /*SelectionRange[] | null*/, error)
  46         PrepareCallHierarchy(context.Context, *CallHierarchyPrepareParams) ([]CallHierarchyItem /*CallHierarchyItem[] | null*/, error)
  47         IncomingCalls(context.Context, *CallHierarchyIncomingCallsParams) ([]CallHierarchyIncomingCall /*CallHierarchyIncomingCall[] | null*/, error)
  48         OutgoingCalls(context.Context, *CallHierarchyOutgoingCallsParams) ([]CallHierarchyOutgoingCall /*CallHierarchyOutgoingCall[] | null*/, error)
  49         SemanticTokensFull(context.Context, *SemanticTokensParams) (*SemanticTokens /*SemanticTokens | null*/, error)
  50         SemanticTokensFullDelta(context.Context, *SemanticTokensDeltaParams) (interface{} /* SemanticTokens | SemanticTokensDelta | nil*/, error)
  51         SemanticTokensRange(context.Context, *SemanticTokensRangeParams) (*SemanticTokens /*SemanticTokens | null*/, error)
  52         SemanticTokensRefresh(context.Context) error
  53         ShowDocument(context.Context, *ShowDocumentParams) (*ShowDocumentResult, error)
  54         LinkedEditingRange(context.Context, *LinkedEditingRangeParams) (*LinkedEditingRanges /*LinkedEditingRanges | null*/, error)
  55         WillCreateFiles(context.Context, *CreateFilesParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error)
  56         WillRenameFiles(context.Context, *RenameFilesParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error)
  57         WillDeleteFiles(context.Context, *DeleteFilesParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error)
  58         Moniker(context.Context, *MonikerParams) ([]Moniker /*Moniker[] | null*/, error)
  59         Initialize(context.Context, *ParamInitialize) (*InitializeResult, error)
  60         Shutdown(context.Context) error
  61         WillSaveWaitUntil(context.Context, *WillSaveTextDocumentParams) ([]TextEdit /*TextEdit[] | null*/, error)
  62         Completion(context.Context, *CompletionParams) (*CompletionList /*CompletionItem[] | CompletionList | null*/, error)
  63         Resolve(context.Context, *CompletionItem) (*CompletionItem, error)
  64         Hover(context.Context, *HoverParams) (*Hover /*Hover | null*/, error)
  65         SignatureHelp(context.Context, *SignatureHelpParams) (*SignatureHelp /*SignatureHelp | null*/, error)
  66         Definition(context.Context, *DefinitionParams) (Definition /*Definition | DefinitionLink[] | null*/, error)
  67         References(context.Context, *ReferenceParams) ([]Location /*Location[] | null*/, error)
  68         DocumentHighlight(context.Context, *DocumentHighlightParams) ([]DocumentHighlight /*DocumentHighlight[] | null*/, error)
  69         DocumentSymbol(context.Context, *DocumentSymbolParams) ([]interface{} /*SymbolInformation[] | DocumentSymbol[] | null*/, error)
  70         CodeAction(context.Context, *CodeActionParams) ([]CodeAction /*(Command | CodeAction)[] | null*/, error)
  71         ResolveCodeAction(context.Context, *CodeAction) (*CodeAction, error)
  72         Symbol(context.Context, *WorkspaceSymbolParams) ([]SymbolInformation /*SymbolInformation[] | null*/, error)
  73         CodeLens(context.Context, *CodeLensParams) ([]CodeLens /*CodeLens[] | null*/, error)
  74         ResolveCodeLens(context.Context, *CodeLens) (*CodeLens, error)
  75         CodeLensRefresh(context.Context) error
  76         DocumentLink(context.Context, *DocumentLinkParams) ([]DocumentLink /*DocumentLink[] | null*/, error)
  77         ResolveDocumentLink(context.Context, *DocumentLink) (*DocumentLink, error)
  78         Formatting(context.Context, *DocumentFormattingParams) ([]TextEdit /*TextEdit[] | null*/, error)
  79         RangeFormatting(context.Context, *DocumentRangeFormattingParams) ([]TextEdit /*TextEdit[] | null*/, error)
  80         OnTypeFormatting(context.Context, *DocumentOnTypeFormattingParams) ([]TextEdit /*TextEdit[] | null*/, error)
  81         Rename(context.Context, *RenameParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error)
  82         PrepareRename(context.Context, *PrepareRenameParams) (*Range /*Range | { range: Range, placeholder: string } | { defaultBehavior: boolean } | null*/, error)
  83         ExecuteCommand(context.Context, *ExecuteCommandParams) (interface{} /*any | null*/, error)
  84         NonstandardRequest(ctx context.Context, method string, params interface{}) (interface{}, error)
  85 }
  86
  87 func serverDispatch(ctx context.Context, server Server, reply jsonrpc2.Replier, r jsonrpc2.Request) (bool, error) {
  88         switch r.Method() {
  89         case "workspace/didChangeWorkspaceFolders": // notif
  90                 var params DidChangeWorkspaceFoldersParams
  91                 if err := json.Unmarshal(r.Params(), &params); err != nil {
  92                         return true, sendParseError(ctx, reply, err)
  93                 }
  94                 err := server.DidChangeWorkspaceFolders(ctx, &params)
  95                 return true, reply(ctx, nil, err)
  96         case "window/workDoneProgress/cancel": // notif
  97                 var params WorkDoneProgressCancelParams
  98                 if err := json.Unmarshal(r.Params(), &params); err != nil {
  99                         return true, sendParseError(ctx, reply, err)
 100                 }
 101                 err := server.WorkDoneProgressCancel(ctx, &params)
 102                 return true, reply(ctx, nil, err)
 103         case "workspace/didCreateFiles": // notif
 104                 var params CreateFilesParams
 105                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 106                         return true, sendParseError(ctx, reply, err)
 107                 }
 108                 err := server.DidCreateFiles(ctx, &params)
 109                 return true, reply(ctx, nil, err)
 110         case "workspace/didRenameFiles": // notif
 111                 var params RenameFilesParams
 112                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 113                         return true, sendParseError(ctx, reply, err)
 114                 }
 115                 err := server.DidRenameFiles(ctx, &params)
 116                 return true, reply(ctx, nil, err)
 117         case "workspace/didDeleteFiles": // notif
 118                 var params DeleteFilesParams
 119                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 120                         return true, sendParseError(ctx, reply, err)
 121                 }
 122                 err := server.DidDeleteFiles(ctx, &params)
 123                 return true, reply(ctx, nil, err)
 124         case "initialized": // notif
 125                 var params InitializedParams
 126                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 127                         return true, sendParseError(ctx, reply, err)
 128                 }
 129                 err := server.Initialized(ctx, &params)
 130                 return true, reply(ctx, nil, err)
 131         case "exit": // notif
 132                 err := server.Exit(ctx)
 133                 return true, reply(ctx, nil, err)
 134         case "workspace/didChangeConfiguration": // notif
 135                 var params DidChangeConfigurationParams
 136                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 137                         return true, sendParseError(ctx, reply, err)
 138                 }
 139                 err := server.DidChangeConfiguration(ctx, &params)
 140                 return true, reply(ctx, nil, err)
 141         case "textDocument/didOpen": // notif
 142                 var params DidOpenTextDocumentParams
 143                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 144                         return true, sendParseError(ctx, reply, err)
 145                 }
 146                 err := server.DidOpen(ctx, &params)
 147                 return true, reply(ctx, nil, err)
 148         case "textDocument/didChange": // notif
 149                 var params DidChangeTextDocumentParams
 150                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 151                         return true, sendParseError(ctx, reply, err)
 152                 }
 153                 err := server.DidChange(ctx, &params)
 154                 return true, reply(ctx, nil, err)
 155         case "textDocument/didClose": // notif
 156                 var params DidCloseTextDocumentParams
 157                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 158                         return true, sendParseError(ctx, reply, err)
 159                 }
 160                 err := server.DidClose(ctx, &params)
 161                 return true, reply(ctx, nil, err)
 162         case "textDocument/didSave": // notif
 163                 var params DidSaveTextDocumentParams
 164                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 165                         return true, sendParseError(ctx, reply, err)
 166                 }
 167                 err := server.DidSave(ctx, &params)
 168                 return true, reply(ctx, nil, err)
 169         case "textDocument/willSave": // notif
 170                 var params WillSaveTextDocumentParams
 171                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 172                         return true, sendParseError(ctx, reply, err)
 173                 }
 174                 err := server.WillSave(ctx, &params)
 175                 return true, reply(ctx, nil, err)
 176         case "workspace/didChangeWatchedFiles": // notif
 177                 var params DidChangeWatchedFilesParams
 178                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 179                         return true, sendParseError(ctx, reply, err)
 180                 }
 181                 err := server.DidChangeWatchedFiles(ctx, &params)
 182                 return true, reply(ctx, nil, err)
 183         case "$/setTrace": // notif
 184                 var params SetTraceParams
 185                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 186                         return true, sendParseError(ctx, reply, err)
 187                 }
 188                 err := server.SetTrace(ctx, &params)
 189                 return true, reply(ctx, nil, err)
 190         case "$/logTrace": // notif
 191                 var params LogTraceParams
 192                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 193                         return true, sendParseError(ctx, reply, err)
 194                 }
 195                 err := server.LogTrace(ctx, &params)
 196                 return true, reply(ctx, nil, err)
 197         case "textDocument/implementation": // req
 198                 var params ImplementationParams
 199                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 200                         return true, sendParseError(ctx, reply, err)
 201                 }
 202                 resp, err := server.Implementation(ctx, &params)
 203                 return true, reply(ctx, resp, err)
 204         case "textDocument/typeDefinition": // req
 205                 var params TypeDefinitionParams
 206                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 207                         return true, sendParseError(ctx, reply, err)
 208                 }
 209                 resp, err := server.TypeDefinition(ctx, &params)
 210                 return true, reply(ctx, resp, err)
 211         case "textDocument/documentColor": // req
 212                 var params DocumentColorParams
 213                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 214                         return true, sendParseError(ctx, reply, err)
 215                 }
 216                 resp, err := server.DocumentColor(ctx, &params)
 217                 return true, reply(ctx, resp, err)
 218         case "textDocument/colorPresentation": // req
 219                 var params ColorPresentationParams
 220                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 221                         return true, sendParseError(ctx, reply, err)
 222                 }
 223                 resp, err := server.ColorPresentation(ctx, &params)
 224                 return true, reply(ctx, resp, err)
 225         case "textDocument/foldingRange": // req
 226                 var params FoldingRangeParams
 227                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 228                         return true, sendParseError(ctx, reply, err)
 229                 }
 230                 resp, err := server.FoldingRange(ctx, &params)
 231                 return true, reply(ctx, resp, err)
 232         case "textDocument/declaration": // req
 233                 var params DeclarationParams
 234                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 235                         return true, sendParseError(ctx, reply, err)
 236                 }
 237                 resp, err := server.Declaration(ctx, &params)
 238                 return true, reply(ctx, resp, err)
 239         case "textDocument/selectionRange": // req
 240                 var params SelectionRangeParams
 241                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 242                         return true, sendParseError(ctx, reply, err)
 243                 }
 244                 resp, err := server.SelectionRange(ctx, &params)
 245                 return true, reply(ctx, resp, err)
 246         case "textDocument/prepareCallHierarchy": // req
 247                 var params CallHierarchyPrepareParams
 248                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 249                         return true, sendParseError(ctx, reply, err)
 250                 }
 251                 resp, err := server.PrepareCallHierarchy(ctx, &params)
 252                 return true, reply(ctx, resp, err)
 253         case "callHierarchy/incomingCalls": // req
 254                 var params CallHierarchyIncomingCallsParams
 255                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 256                         return true, sendParseError(ctx, reply, err)
 257                 }
 258                 resp, err := server.IncomingCalls(ctx, &params)
 259                 return true, reply(ctx, resp, err)
 260         case "callHierarchy/outgoingCalls": // req
 261                 var params CallHierarchyOutgoingCallsParams
 262                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 263                         return true, sendParseError(ctx, reply, err)
 264                 }
 265                 resp, err := server.OutgoingCalls(ctx, &params)
 266                 return true, reply(ctx, resp, err)
 267         case "textDocument/semanticTokens/full": // req
 268                 var params SemanticTokensParams
 269                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 270                         return true, sendParseError(ctx, reply, err)
 271                 }
 272                 resp, err := server.SemanticTokensFull(ctx, &params)
 273                 return true, reply(ctx, resp, err)
 274         case "textDocument/semanticTokens/full/delta": // req
 275                 var params SemanticTokensDeltaParams
 276                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 277                         return true, sendParseError(ctx, reply, err)
 278                 }
 279                 resp, err := server.SemanticTokensFullDelta(ctx, &params)
 280                 return true, reply(ctx, resp, err)
 281         case "textDocument/semanticTokens/range": // req
 282                 var params SemanticTokensRangeParams
 283                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 284                         return true, sendParseError(ctx, reply, err)
 285                 }
 286                 resp, err := server.SemanticTokensRange(ctx, &params)
 287                 return true, reply(ctx, resp, err)
 288         case "workspace/semanticTokens/refresh": // req
 289                 if len(r.Params()) > 0 {
 290                         return true, reply(ctx, nil, errors.Errorf("%w: expected no params", jsonrpc2.ErrInvalidParams))
 291                 }
 292                 err := server.SemanticTokensRefresh(ctx)
 293                 return true, reply(ctx, nil, err)
 294         case "window/showDocument": // req
 295                 var params ShowDocumentParams
 296                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 297                         return true, sendParseError(ctx, reply, err)
 298                 }
 299                 resp, err := server.ShowDocument(ctx, &params)
 300                 return true, reply(ctx, resp, err)
 301         case "textDocument/linkedEditingRange": // req
 302                 var params LinkedEditingRangeParams
 303                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 304                         return true, sendParseError(ctx, reply, err)
 305                 }
 306                 resp, err := server.LinkedEditingRange(ctx, &params)
 307                 return true, reply(ctx, resp, err)
 308         case "workspace/willCreateFiles": // req
 309                 var params CreateFilesParams
 310                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 311                         return true, sendParseError(ctx, reply, err)
 312                 }
 313                 resp, err := server.WillCreateFiles(ctx, &params)
 314                 return true, reply(ctx, resp, err)
 315         case "workspace/willRenameFiles": // req
 316                 var params RenameFilesParams
 317                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 318                         return true, sendParseError(ctx, reply, err)
 319                 }
 320                 resp, err := server.WillRenameFiles(ctx, &params)
 321                 return true, reply(ctx, resp, err)
 322         case "workspace/willDeleteFiles": // req
 323                 var params DeleteFilesParams
 324                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 325                         return true, sendParseError(ctx, reply, err)
 326                 }
 327                 resp, err := server.WillDeleteFiles(ctx, &params)
 328                 return true, reply(ctx, resp, err)
 329         case "textDocument/moniker": // req
 330                 var params MonikerParams
 331                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 332                         return true, sendParseError(ctx, reply, err)
 333                 }
 334                 resp, err := server.Moniker(ctx, &params)
 335                 return true, reply(ctx, resp, err)
 336         case "initialize": // req
 337                 var params ParamInitialize
 338                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 339                         return true, sendParseError(ctx, reply, err)
 340                 }
 341                 resp, err := server.Initialize(ctx, &params)
 342                 return true, reply(ctx, resp, err)
 343         case "shutdown": // req
 344                 if len(r.Params()) > 0 {
 345                         return true, reply(ctx, nil, errors.Errorf("%w: expected no params", jsonrpc2.ErrInvalidParams))
 346                 }
 347                 err := server.Shutdown(ctx)
 348                 return true, reply(ctx, nil, err)
 349         case "textDocument/willSaveWaitUntil": // req
 350                 var params WillSaveTextDocumentParams
 351                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 352                         return true, sendParseError(ctx, reply, err)
 353                 }
 354                 resp, err := server.WillSaveWaitUntil(ctx, &params)
 355                 return true, reply(ctx, resp, err)
 356         case "textDocument/completion": // req
 357                 var params CompletionParams
 358                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 359                         return true, sendParseError(ctx, reply, err)
 360                 }
 361                 resp, err := server.Completion(ctx, &params)
 362                 return true, reply(ctx, resp, err)
 363         case "completionItem/resolve": // req
 364                 var params CompletionItem
 365                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 366                         return true, sendParseError(ctx, reply, err)
 367                 }
 368                 resp, err := server.Resolve(ctx, &params)
 369                 return true, reply(ctx, resp, err)
 370         case "textDocument/hover": // req
 371                 var params HoverParams
 372                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 373                         return true, sendParseError(ctx, reply, err)
 374                 }
 375                 resp, err := server.Hover(ctx, &params)
 376                 return true, reply(ctx, resp, err)
 377         case "textDocument/signatureHelp": // req
 378                 var params SignatureHelpParams
 379                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 380                         return true, sendParseError(ctx, reply, err)
 381                 }
 382                 resp, err := server.SignatureHelp(ctx, &params)
 383                 return true, reply(ctx, resp, err)
 384         case "textDocument/definition": // req
 385                 var params DefinitionParams
 386                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 387                         return true, sendParseError(ctx, reply, err)
 388                 }
 389                 resp, err := server.Definition(ctx, &params)
 390                 return true, reply(ctx, resp, err)
 391         case "textDocument/references": // req
 392                 var params ReferenceParams
 393                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 394                         return true, sendParseError(ctx, reply, err)
 395                 }
 396                 resp, err := server.References(ctx, &params)
 397                 return true, reply(ctx, resp, err)
 398         case "textDocument/documentHighlight": // req
 399                 var params DocumentHighlightParams
 400                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 401                         return true, sendParseError(ctx, reply, err)
 402                 }
 403                 resp, err := server.DocumentHighlight(ctx, &params)
 404                 return true, reply(ctx, resp, err)
 405         case "textDocument/documentSymbol": // req
 406                 var params DocumentSymbolParams
 407                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 408                         return true, sendParseError(ctx, reply, err)
 409                 }
 410                 resp, err := server.DocumentSymbol(ctx, &params)
 411                 return true, reply(ctx, resp, err)
 412         case "textDocument/codeAction": // req
 413                 var params CodeActionParams
 414                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 415                         return true, sendParseError(ctx, reply, err)
 416                 }
 417                 resp, err := server.CodeAction(ctx, &params)
 418                 return true, reply(ctx, resp, err)
 419         case "codeAction/resolve": // req
 420                 var params CodeAction
 421                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 422                         return true, sendParseError(ctx, reply, err)
 423                 }
 424                 resp, err := server.ResolveCodeAction(ctx, &params)
 425                 return true, reply(ctx, resp, err)
 426         case "workspace/symbol": // req
 427                 var params WorkspaceSymbolParams
 428                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 429                         return true, sendParseError(ctx, reply, err)
 430                 }
 431                 resp, err := server.Symbol(ctx, &params)
 432                 return true, reply(ctx, resp, err)
 433         case "textDocument/codeLens": // req
 434                 var params CodeLensParams
 435                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 436                         return true, sendParseError(ctx, reply, err)
 437                 }
 438                 resp, err := server.CodeLens(ctx, &params)
 439                 return true, reply(ctx, resp, err)
 440         case "codeLens/resolve": // req
 441                 var params CodeLens
 442                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 443                         return true, sendParseError(ctx, reply, err)
 444                 }
 445                 resp, err := server.ResolveCodeLens(ctx, &params)
 446                 return true, reply(ctx, resp, err)
 447         case "workspace/codeLens/refresh": // req
 448                 if len(r.Params()) > 0 {
 449                         return true, reply(ctx, nil, errors.Errorf("%w: expected no params", jsonrpc2.ErrInvalidParams))
 450                 }
 451                 err := server.CodeLensRefresh(ctx)
 452                 return true, reply(ctx, nil, err)
 453         case "textDocument/documentLink": // req
 454                 var params DocumentLinkParams
 455                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 456                         return true, sendParseError(ctx, reply, err)
 457                 }
 458                 resp, err := server.DocumentLink(ctx, &params)
 459                 return true, reply(ctx, resp, err)
 460         case "documentLink/resolve": // req
 461                 var params DocumentLink
 462                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 463                         return true, sendParseError(ctx, reply, err)
 464                 }
 465                 resp, err := server.ResolveDocumentLink(ctx, &params)
 466                 return true, reply(ctx, resp, err)
 467         case "textDocument/formatting": // req
 468                 var params DocumentFormattingParams
 469                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 470                         return true, sendParseError(ctx, reply, err)
 471                 }
 472                 resp, err := server.Formatting(ctx, &params)
 473                 return true, reply(ctx, resp, err)
 474         case "textDocument/rangeFormatting": // req
 475                 var params DocumentRangeFormattingParams
 476                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 477                         return true, sendParseError(ctx, reply, err)
 478                 }
 479                 resp, err := server.RangeFormatting(ctx, &params)
 480                 return true, reply(ctx, resp, err)
 481         case "textDocument/onTypeFormatting": // req
 482                 var params DocumentOnTypeFormattingParams
 483                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 484                         return true, sendParseError(ctx, reply, err)
 485                 }
 486                 resp, err := server.OnTypeFormatting(ctx, &params)
 487                 return true, reply(ctx, resp, err)
 488         case "textDocument/rename": // req
 489                 var params RenameParams
 490                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 491                         return true, sendParseError(ctx, reply, err)
 492                 }
 493                 resp, err := server.Rename(ctx, &params)
 494                 return true, reply(ctx, resp, err)
 495         case "textDocument/prepareRename": // req
 496                 var params PrepareRenameParams
 497                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 498                         return true, sendParseError(ctx, reply, err)
 499                 }
 500                 resp, err := server.PrepareRename(ctx, &params)
 501                 return true, reply(ctx, resp, err)
 502         case "workspace/executeCommand": // req
 503                 var params ExecuteCommandParams
 504                 if err := json.Unmarshal(r.Params(), &params); err != nil {
 505                         return true, sendParseError(ctx, reply, err)
 506                 }
 507                 resp, err := server.ExecuteCommand(ctx, &params)
 508                 return true, reply(ctx, resp, err)
 509
 510         default:
 511                 return false, nil
 512         }
 513 }
 514
 515 func (s *serverDispatcher) DidChangeWorkspaceFolders(ctx context.Context, params *DidChangeWorkspaceFoldersParams) error {
 516         return s.Conn.Notify(ctx, "workspace/didChangeWorkspaceFolders", params)
 517 }
 518
 519 func (s *serverDispatcher) WorkDoneProgressCancel(ctx context.Context, params *WorkDoneProgressCancelParams) error {
 520         return s.Conn.Notify(ctx, "window/workDoneProgress/cancel", params)
 521 }
 522
 523 func (s *serverDispatcher) DidCreateFiles(ctx context.Context, params *CreateFilesParams) error {
 524         return s.Conn.Notify(ctx, "workspace/didCreateFiles", params)
 525 }
 526
 527 func (s *serverDispatcher) DidRenameFiles(ctx context.Context, params *RenameFilesParams) error {
 528         return s.Conn.Notify(ctx, "workspace/didRenameFiles", params)
 529 }
 530
 531 func (s *serverDispatcher) DidDeleteFiles(ctx context.Context, params *DeleteFilesParams) error {
 532         return s.Conn.Notify(ctx, "workspace/didDeleteFiles", params)
 533 }
 534
 535 func (s *serverDispatcher) Initialized(ctx context.Context, params *InitializedParams) error {
 536         return s.Conn.Notify(ctx, "initialized", params)
 537 }
 538
 539 func (s *serverDispatcher) Exit(ctx context.Context) error {
 540         return s.Conn.Notify(ctx, "exit", nil)
 541 }
 542
 543 func (s *serverDispatcher) DidChangeConfiguration(ctx context.Context, params *DidChangeConfigurationParams) error {
 544         return s.Conn.Notify(ctx, "workspace/didChangeConfiguration", params)
 545 }
 546
 547 func (s *serverDispatcher) DidOpen(ctx context.Context, params *DidOpenTextDocumentParams) error {
 548         return s.Conn.Notify(ctx, "textDocument/didOpen", params)
 549 }
 550
 551 func (s *serverDispatcher) DidChange(ctx context.Context, params *DidChangeTextDocumentParams) error {
 552         return s.Conn.Notify(ctx, "textDocument/didChange", params)
 553 }
 554
 555 func (s *serverDispatcher) DidClose(ctx context.Context, params *DidCloseTextDocumentParams) error {
 556         return s.Conn.Notify(ctx, "textDocument/didClose", params)
 557 }
 558
 559 func (s *serverDispatcher) DidSave(ctx context.Context, params *DidSaveTextDocumentParams) error {
 560         return s.Conn.Notify(ctx, "textDocument/didSave", params)
 561 }
 562
 563 func (s *serverDispatcher) WillSave(ctx context.Context, params *WillSaveTextDocumentParams) error {
 564         return s.Conn.Notify(ctx, "textDocument/willSave", params)
 565 }
 566
 567 func (s *serverDispatcher) DidChangeWatchedFiles(ctx context.Context, params *DidChangeWatchedFilesParams) error {
 568         return s.Conn.Notify(ctx, "workspace/didChangeWatchedFiles", params)
 569 }
 570
 571 func (s *serverDispatcher) SetTrace(ctx context.Context, params *SetTraceParams) error {
 572         return s.Conn.Notify(ctx, "$/setTrace", params)
 573 }
 574
 575 func (s *serverDispatcher) LogTrace(ctx context.Context, params *LogTraceParams) error {
 576         return s.Conn.Notify(ctx, "$/logTrace", params)
 577 }
 578 func (s *serverDispatcher) Implementation(ctx context.Context, params *ImplementationParams) (Definition /*Definition | DefinitionLink[] | null*/, error) {
 579         var result Definition /*Definition | DefinitionLink[] | null*/
 580         if err := Call(ctx, s.Conn, "textDocument/implementation", params, &result); err != nil {
 581                 return nil, err
 582         }
 583         return result, nil
 584 }
 585
 586 func (s *serverDispatcher) TypeDefinition(ctx context.Context, params *TypeDefinitionParams) (Definition /*Definition | DefinitionLink[] | null*/, error) {
 587         var result Definition /*Definition | DefinitionLink[] | null*/
 588         if err := Call(ctx, s.Conn, "textDocument/typeDefinition", params, &result); err != nil {
 589                 return nil, err
 590         }
 591         return result, nil
 592 }
 593
 594 func (s *serverDispatcher) DocumentColor(ctx context.Context, params *DocumentColorParams) ([]ColorInformation, error) {
 595         var result []ColorInformation
 596         if err := Call(ctx, s.Conn, "textDocument/documentColor", params, &result); err != nil {
 597                 return nil, err
 598         }
 599         return result, nil
 600 }
 601
 602 func (s *serverDispatcher) ColorPresentation(ctx context.Context, params *ColorPresentationParams) ([]ColorPresentation, error) {
 603         var result []ColorPresentation
 604         if err := Call(ctx, s.Conn, "textDocument/colorPresentation", params, &result); err != nil {
 605                 return nil, err
 606         }
 607         return result, nil
 608 }
 609
 610 func (s *serverDispatcher) FoldingRange(ctx context.Context, params *FoldingRangeParams) ([]FoldingRange /*FoldingRange[] | null*/, error) {
 611         var result []FoldingRange /*FoldingRange[] | null*/
 612         if err := Call(ctx, s.Conn, "textDocument/foldingRange", params, &result); err != nil {
 613                 return nil, err
 614         }
 615         return result, nil
 616 }
 617
 618 func (s *serverDispatcher) Declaration(ctx context.Context, params *DeclarationParams) (Declaration /*Declaration | DeclarationLink[] | null*/, error) {
 619         var result Declaration /*Declaration | DeclarationLink[] | null*/
 620         if err := Call(ctx, s.Conn, "textDocument/declaration", params, &result); err != nil {
 621                 return nil, err
 622         }
 623         return result, nil
 624 }
 625
 626 func (s *serverDispatcher) SelectionRange(ctx context.Context, params *SelectionRangeParams) ([]SelectionRange /*SelectionRange[] | null*/, error) {
 627         var result []SelectionRange /*SelectionRange[] | null*/
 628         if err := Call(ctx, s.Conn, "textDocument/selectionRange", params, &result); err != nil {
 629                 return nil, err
 630         }
 631         return result, nil
 632 }
 633
 634 func (s *serverDispatcher) PrepareCallHierarchy(ctx context.Context, params *CallHierarchyPrepareParams) ([]CallHierarchyItem /*CallHierarchyItem[] | null*/, error) {
 635         var result []CallHierarchyItem /*CallHierarchyItem[] | null*/
 636         if err := Call(ctx, s.Conn, "textDocument/prepareCallHierarchy", params, &result); err != nil {
 637                 return nil, err
 638         }
 639         return result, nil
 640 }
 641
 642 func (s *serverDispatcher) IncomingCalls(ctx context.Context, params *CallHierarchyIncomingCallsParams) ([]CallHierarchyIncomingCall /*CallHierarchyIncomingCall[] | null*/, error) {
 643         var result []CallHierarchyIncomingCall /*CallHierarchyIncomingCall[] | null*/
 644         if err := Call(ctx, s.Conn, "callHierarchy/incomingCalls", params, &result); err != nil {
 645                 return nil, err
 646         }
 647         return result, nil
 648 }
 649
 650 func (s *serverDispatcher) OutgoingCalls(ctx context.Context, params *CallHierarchyOutgoingCallsParams) ([]CallHierarchyOutgoingCall /*CallHierarchyOutgoingCall[] | null*/, error) {
 651         var result []CallHierarchyOutgoingCall /*CallHierarchyOutgoingCall[] | null*/
 652         if err := Call(ctx, s.Conn, "callHierarchy/outgoingCalls", params, &result); err != nil {
 653                 return nil, err
 654         }
 655         return result, nil
 656 }
 657
 658 func (s *serverDispatcher) SemanticTokensFull(ctx context.Context, params *SemanticTokensParams) (*SemanticTokens /*SemanticTokens | null*/, error) {
 659         var result *SemanticTokens /*SemanticTokens | null*/
 660         if err := Call(ctx, s.Conn, "textDocument/semanticTokens/full", params, &result); err != nil {
 661                 return nil, err
 662         }
 663         return result, nil
 664 }
 665
 666 func (s *serverDispatcher) SemanticTokensFullDelta(ctx context.Context, params *SemanticTokensDeltaParams) (interface{} /* SemanticTokens | SemanticTokensDelta | nil*/, error) {
 667         var result interface{} /* SemanticTokens | SemanticTokensDelta | nil*/
 668         if err := Call(ctx, s.Conn, "textDocument/semanticTokens/full/delta", params, &result); err != nil {
 669                 return nil, err
 670         }
 671         return result, nil
 672 }
 673
 674 func (s *serverDispatcher) SemanticTokensRange(ctx context.Context, params *SemanticTokensRangeParams) (*SemanticTokens /*SemanticTokens | null*/, error) {
 675         var result *SemanticTokens /*SemanticTokens | null*/
 676         if err := Call(ctx, s.Conn, "textDocument/semanticTokens/range", params, &result); err != nil {
 677                 return nil, err
 678         }
 679         return result, nil
 680 }
 681
 682 func (s *serverDispatcher) SemanticTokensRefresh(ctx context.Context) error {
 683         return Call(ctx, s.Conn, "workspace/semanticTokens/refresh", nil, nil)
 684 }
 685
 686 func (s *serverDispatcher) ShowDocument(ctx context.Context, params *ShowDocumentParams) (*ShowDocumentResult, error) {
 687         var result *ShowDocumentResult
 688         if err := Call(ctx, s.Conn, "window/showDocument", params, &result); err != nil {
 689                 return nil, err
 690         }
 691         return result, nil
 692 }
 693
 694 func (s *serverDispatcher) LinkedEditingRange(ctx context.Context, params *LinkedEditingRangeParams) (*LinkedEditingRanges /*LinkedEditingRanges | null*/, error) {
 695         var result *LinkedEditingRanges /*LinkedEditingRanges | null*/
 696         if err := Call(ctx, s.Conn, "textDocument/linkedEditingRange", params, &result); err != nil {
 697                 return nil, err
 698         }
 699         return result, nil
 700 }
 701
 702 func (s *serverDispatcher) WillCreateFiles(ctx context.Context, params *CreateFilesParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error) {
 703         var result *WorkspaceEdit /*WorkspaceEdit | null*/
 704         if err := Call(ctx, s.Conn, "workspace/willCreateFiles", params, &result); err != nil {
 705                 return nil, err
 706         }
 707         return result, nil
 708 }
 709
 710 func (s *serverDispatcher) WillRenameFiles(ctx context.Context, params *RenameFilesParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error) {
 711         var result *WorkspaceEdit /*WorkspaceEdit | null*/
 712         if err := Call(ctx, s.Conn, "workspace/willRenameFiles", params, &result); err != nil {
 713                 return nil, err
 714         }
 715         return result, nil
 716 }
 717
 718 func (s *serverDispatcher) WillDeleteFiles(ctx context.Context, params *DeleteFilesParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error) {
 719         var result *WorkspaceEdit /*WorkspaceEdit | null*/
 720         if err := Call(ctx, s.Conn, "workspace/willDeleteFiles", params, &result); err != nil {
 721                 return nil, err
 722         }
 723         return result, nil
 724 }
 725
 726 func (s *serverDispatcher) Moniker(ctx context.Context, params *MonikerParams) ([]Moniker /*Moniker[] | null*/, error) {
 727         var result []Moniker /*Moniker[] | null*/
 728         if err := Call(ctx, s.Conn, "textDocument/moniker", params, &result); err != nil {
 729                 return nil, err
 730         }
 731         return result, nil
 732 }
 733
 734 func (s *serverDispatcher) Initialize(ctx context.Context, params *ParamInitialize) (*InitializeResult, error) {
 735         var result *InitializeResult
 736         if err := Call(ctx, s.Conn, "initialize", params, &result); err != nil {
 737                 return nil, err
 738         }
 739         return result, nil
 740 }
 741
 742 func (s *serverDispatcher) Shutdown(ctx context.Context) error {
 743         return Call(ctx, s.Conn, "shutdown", nil, nil)
 744 }
 745
 746 func (s *serverDispatcher) WillSaveWaitUntil(ctx context.Context, params *WillSaveTextDocumentParams) ([]TextEdit /*TextEdit[] | null*/, error) {
 747         var result []TextEdit /*TextEdit[] | null*/
 748         if err := Call(ctx, s.Conn, "textDocument/willSaveWaitUntil", params, &result); err != nil {
 749                 return nil, err
 750         }
 751         return result, nil
 752 }
 753
 754 func (s *serverDispatcher) Completion(ctx context.Context, params *CompletionParams) (*CompletionList /*CompletionItem[] | CompletionList | null*/, error) {
 755         var result *CompletionList /*CompletionItem[] | CompletionList | null*/
 756         if err := Call(ctx, s.Conn, "textDocument/completion", params, &result); err != nil {
 757                 return nil, err
 758         }
 759         return result, nil
 760 }
 761
 762 func (s *serverDispatcher) Resolve(ctx context.Context, params *CompletionItem) (*CompletionItem, error) {
 763         var result *CompletionItem
 764         if err := Call(ctx, s.Conn, "completionItem/resolve", params, &result); err != nil {
 765                 return nil, err
 766         }
 767         return result, nil
 768 }
 769
 770 func (s *serverDispatcher) Hover(ctx context.Context, params *HoverParams) (*Hover /*Hover | null*/, error) {
 771         var result *Hover /*Hover | null*/
 772         if err := Call(ctx, s.Conn, "textDocument/hover", params, &result); err != nil {
 773                 return nil, err
 774         }
 775         return result, nil
 776 }
 777
 778 func (s *serverDispatcher) SignatureHelp(ctx context.Context, params *SignatureHelpParams) (*SignatureHelp /*SignatureHelp | null*/, error) {
 779         var result *SignatureHelp /*SignatureHelp | null*/
 780         if err := Call(ctx, s.Conn, "textDocument/signatureHelp", params, &result); err != nil {
 781                 return nil, err
 782         }
 783         return result, nil
 784 }
 785
 786 func (s *serverDispatcher) Definition(ctx context.Context, params *DefinitionParams) (Definition /*Definition | DefinitionLink[] | null*/, error) {
 787         var result Definition /*Definition | DefinitionLink[] | null*/
 788         if err := Call(ctx, s.Conn, "textDocument/definition", params, &result); err != nil {
 789                 return nil, err
 790         }
 791         return result, nil
 792 }
 793
 794 func (s *serverDispatcher) References(ctx context.Context, params *ReferenceParams) ([]Location /*Location[] | null*/, error) {
 795         var result []Location /*Location[] | null*/
 796         if err := Call(ctx, s.Conn, "textDocument/references", params, &result); err != nil {
 797                 return nil, err
 798         }
 799         return result, nil
 800 }
 801
 802 func (s *serverDispatcher) DocumentHighlight(ctx context.Context, params *DocumentHighlightParams) ([]DocumentHighlight /*DocumentHighlight[] | null*/, error) {
 803         var result []DocumentHighlight /*DocumentHighlight[] | null*/
 804         if err := Call(ctx, s.Conn, "textDocument/documentHighlight", params, &result); err != nil {
 805                 return nil, err
 806         }
 807         return result, nil
 808 }
 809
 810 func (s *serverDispatcher) DocumentSymbol(ctx context.Context, params *DocumentSymbolParams) ([]interface{} /*SymbolInformation[] | DocumentSymbol[] | null*/, error) {
 811         var result []interface{} /*SymbolInformation[] | DocumentSymbol[] | null*/
 812         if err := Call(ctx, s.Conn, "textDocument/documentSymbol", params, &result); err != nil {
 813                 return nil, err
 814         }
 815         return result, nil
 816 }
 817
 818 func (s *serverDispatcher) CodeAction(ctx context.Context, params *CodeActionParams) ([]CodeAction /*(Command | CodeAction)[] | null*/, error) {
 819         var result []CodeAction /*(Command | CodeAction)[] | null*/
 820         if err := Call(ctx, s.Conn, "textDocument/codeAction", params, &result); err != nil {
 821                 return nil, err
 822         }
 823         return result, nil
 824 }
 825
 826 func (s *serverDispatcher) ResolveCodeAction(ctx context.Context, params *CodeAction) (*CodeAction, error) {
 827         var result *CodeAction
 828         if err := Call(ctx, s.Conn, "codeAction/resolve", params, &result); err != nil {
 829                 return nil, err
 830         }
 831         return result, nil
 832 }
 833
 834 func (s *serverDispatcher) Symbol(ctx context.Context, params *WorkspaceSymbolParams) ([]SymbolInformation /*SymbolInformation[] | null*/, error) {
 835         var result []SymbolInformation /*SymbolInformation[] | null*/
 836         if err := Call(ctx, s.Conn, "workspace/symbol", params, &result); err != nil {
 837                 return nil, err
 838         }
 839         return result, nil
 840 }
 841
 842 func (s *serverDispatcher) CodeLens(ctx context.Context, params *CodeLensParams) ([]CodeLens /*CodeLens[] | null*/, error) {
 843         var result []CodeLens /*CodeLens[] | null*/
 844         if err := Call(ctx, s.Conn, "textDocument/codeLens", params, &result); err != nil {
 845                 return nil, err
 846         }
 847         return result, nil
 848 }
 849
 850 func (s *serverDispatcher) ResolveCodeLens(ctx context.Context, params *CodeLens) (*CodeLens, error) {
 851         var result *CodeLens
 852         if err := Call(ctx, s.Conn, "codeLens/resolve", params, &result); err != nil {
 853                 return nil, err
 854         }
 855         return result, nil
 856 }
 857
 858 func (s *serverDispatcher) CodeLensRefresh(ctx context.Context) error {
 859         return Call(ctx, s.Conn, "workspace/codeLens/refresh", nil, nil)
 860 }
 861
 862 func (s *serverDispatcher) DocumentLink(ctx context.Context, params *DocumentLinkParams) ([]DocumentLink /*DocumentLink[] | null*/, error) {
 863         var result []DocumentLink /*DocumentLink[] | null*/
 864         if err := Call(ctx, s.Conn, "textDocument/documentLink", params, &result); err != nil {
 865                 return nil, err
 866         }
 867         return result, nil
 868 }
 869
 870 func (s *serverDispatcher) ResolveDocumentLink(ctx context.Context, params *DocumentLink) (*DocumentLink, error) {
 871         var result *DocumentLink
 872         if err := Call(ctx, s.Conn, "documentLink/resolve", params, &result); err != nil {
 873                 return nil, err
 874         }
 875         return result, nil
 876 }
 877
 878 func (s *serverDispatcher) Formatting(ctx context.Context, params *DocumentFormattingParams) ([]TextEdit /*TextEdit[] | null*/, error) {
 879         var result []TextEdit /*TextEdit[] | null*/
 880         if err := Call(ctx, s.Conn, "textDocument/formatting", params, &result); err != nil {
 881                 return nil, err
 882         }
 883         return result, nil
 884 }
 885
 886 func (s *serverDispatcher) RangeFormatting(ctx context.Context, params *DocumentRangeFormattingParams) ([]TextEdit /*TextEdit[] | null*/, error) {
 887         var result []TextEdit /*TextEdit[] | null*/
 888         if err := Call(ctx, s.Conn, "textDocument/rangeFormatting", params, &result); err != nil {
 889                 return nil, err
 890         }
 891         return result, nil
 892 }
 893
 894 func (s *serverDispatcher) OnTypeFormatting(ctx context.Context, params *DocumentOnTypeFormattingParams) ([]TextEdit /*TextEdit[] | null*/, error) {
 895         var result []TextEdit /*TextEdit[] | null*/
 896         if err := Call(ctx, s.Conn, "textDocument/onTypeFormatting", params, &result); err != nil {
 897                 return nil, err
 898         }
 899         return result, nil
 900 }
 901
 902 func (s *serverDispatcher) Rename(ctx context.Context, params *RenameParams) (*WorkspaceEdit /*WorkspaceEdit | null*/, error) {
 903         var result *WorkspaceEdit /*WorkspaceEdit | null*/
 904         if err := Call(ctx, s.Conn, "textDocument/rename", params, &result); err != nil {
 905                 return nil, err
 906         }
 907         return result, nil
 908 }
 909
 910 func (s *serverDispatcher) PrepareRename(ctx context.Context, params *PrepareRenameParams) (*Range /*Range | { range: Range, placeholder: string } | { defaultBehavior: boolean } | null*/, error) {
 911         var result *Range /*Range | { range: Range, placeholder: string } | { defaultBehavior: boolean } | null*/
 912         if err := Call(ctx, s.Conn, "textDocument/prepareRename", params, &result); err != nil {
 913                 return nil, err
 914         }
 915         return result, nil
 916 }
 917
 918 func (s *serverDispatcher) ExecuteCommand(ctx context.Context, params *ExecuteCommandParams) (interface{} /*any | null*/, error) {
 919         var result interface{} /*any | null*/
 920         if err := Call(ctx, s.Conn, "workspace/executeCommand", params, &result); err != nil {
 921                 return nil, err
 922         }
 923         return result, nil
 924 }
 925
 926 func (s *serverDispatcher) NonstandardRequest(ctx context.Context, method string, params interface{}) (interface{}, error) {
 927         var result interface{}
 928         if err := Call(ctx, s.Conn, method, params, &result); err != nil {
 929                 return nil, err
 930         }
 931         return result, nil
 932 }