diff options
Diffstat (limited to 'gopls/internal/lsp/protocol')
22 files changed, 12572 insertions, 0 deletions
diff --git a/gopls/internal/lsp/protocol/codeactionkind.go b/gopls/internal/lsp/protocol/codeactionkind.go new file mode 100644 index 000000000..9a95800fb --- /dev/null +++ b/gopls/internal/lsp/protocol/codeactionkind.go @@ -0,0 +1,11 @@ +// Copyright 2020 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +// Custom code actions that aren't explicitly stated in LSP +const ( + GoTest CodeActionKind = "goTest" + // TODO: Add GoGenerate, RegenerateCgo etc. +) diff --git a/gopls/internal/lsp/protocol/context.go b/gopls/internal/lsp/protocol/context.go new file mode 100644 index 000000000..487e4dfe5 --- /dev/null +++ b/gopls/internal/lsp/protocol/context.go @@ -0,0 +1,43 @@ +// Copyright 2019 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +import ( + "bytes" + "context" + + "golang.org/x/tools/internal/event" + "golang.org/x/tools/internal/event/core" + "golang.org/x/tools/internal/event/export" + "golang.org/x/tools/internal/event/label" + "golang.org/x/tools/internal/xcontext" +) + +type contextKey int + +const ( + clientKey = contextKey(iota) +) + +func WithClient(ctx context.Context, client Client) context.Context { + return context.WithValue(ctx, clientKey, client) +} + +func LogEvent(ctx context.Context, ev core.Event, lm label.Map, mt MessageType) context.Context { + client, ok := ctx.Value(clientKey).(Client) + if !ok { + return ctx + } + buf := &bytes.Buffer{} + p := export.Printer{} + p.WriteEvent(buf, ev, lm) + msg := &LogMessageParams{Type: mt, Message: buf.String()} + // Handle messages generated via event.Error, which won't have a level Label. + if event.IsError(ev) { + msg.Type = Error + } + go client.LogMessage(xcontext.Detach(ctx), msg) + return ctx +} diff --git a/gopls/internal/lsp/protocol/doc.go b/gopls/internal/lsp/protocol/doc.go new file mode 100644 index 000000000..4a7f90439 --- /dev/null +++ b/gopls/internal/lsp/protocol/doc.go @@ -0,0 +1,18 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:generate go run ./generate + +// Package protocol contains the structs that map directly to the +// request and response messages of the Language Server Protocol. +// +// It is a literal transcription, with unmodified comments, and only the changes +// required to make it go code. +// Names are uppercased to export them. +// All fields have JSON tags added to correct the names. +// Fields marked with a ? are also marked as "omitempty" +// Fields that are "|| null" are made pointers +// Fields that are string or number are left as string +// Fields that are type "number" are made float64 +package protocol diff --git a/gopls/internal/lsp/protocol/enums.go b/gopls/internal/lsp/protocol/enums.go new file mode 100644 index 000000000..82398e221 --- /dev/null +++ b/gopls/internal/lsp/protocol/enums.go @@ -0,0 +1,231 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +import ( + "fmt" +) + +var ( + namesTextDocumentSyncKind [int(Incremental) + 1]string + namesMessageType [int(Log) + 1]string + namesFileChangeType [int(Deleted) + 1]string + namesWatchKind [int(WatchDelete) + 1]string + namesCompletionTriggerKind [int(TriggerForIncompleteCompletions) + 1]string + namesDiagnosticSeverity [int(SeverityHint) + 1]string + namesDiagnosticTag [int(Unnecessary) + 1]string + namesCompletionItemKind [int(TypeParameterCompletion) + 1]string + namesInsertTextFormat [int(SnippetTextFormat) + 1]string + namesDocumentHighlightKind [int(Write) + 1]string + namesSymbolKind [int(TypeParameter) + 1]string + namesTextDocumentSaveReason [int(FocusOut) + 1]string +) + +func init() { + namesTextDocumentSyncKind[int(None)] = "None" + namesTextDocumentSyncKind[int(Full)] = "Full" + namesTextDocumentSyncKind[int(Incremental)] = "Incremental" + + namesMessageType[int(Error)] = "Error" + namesMessageType[int(Warning)] = "Warning" + namesMessageType[int(Info)] = "Info" + namesMessageType[int(Log)] = "Log" + + namesFileChangeType[int(Created)] = "Created" + namesFileChangeType[int(Changed)] = "Changed" + namesFileChangeType[int(Deleted)] = "Deleted" + + namesWatchKind[int(WatchCreate)] = "WatchCreate" + namesWatchKind[int(WatchChange)] = "WatchChange" + namesWatchKind[int(WatchDelete)] = "WatchDelete" + + namesCompletionTriggerKind[int(Invoked)] = "Invoked" + namesCompletionTriggerKind[int(TriggerCharacter)] = "TriggerCharacter" + namesCompletionTriggerKind[int(TriggerForIncompleteCompletions)] = "TriggerForIncompleteCompletions" + + namesDiagnosticSeverity[int(SeverityError)] = "Error" + namesDiagnosticSeverity[int(SeverityWarning)] = "Warning" + namesDiagnosticSeverity[int(SeverityInformation)] = "Information" + namesDiagnosticSeverity[int(SeverityHint)] = "Hint" + + namesDiagnosticTag[int(Unnecessary)] = "Unnecessary" + + namesCompletionItemKind[int(TextCompletion)] = "text" + namesCompletionItemKind[int(MethodCompletion)] = "method" + namesCompletionItemKind[int(FunctionCompletion)] = "func" + namesCompletionItemKind[int(ConstructorCompletion)] = "constructor" + namesCompletionItemKind[int(FieldCompletion)] = "field" + namesCompletionItemKind[int(VariableCompletion)] = "var" + namesCompletionItemKind[int(ClassCompletion)] = "type" + namesCompletionItemKind[int(InterfaceCompletion)] = "interface" + namesCompletionItemKind[int(ModuleCompletion)] = "package" + namesCompletionItemKind[int(PropertyCompletion)] = "property" + namesCompletionItemKind[int(UnitCompletion)] = "unit" + namesCompletionItemKind[int(ValueCompletion)] = "value" + namesCompletionItemKind[int(EnumCompletion)] = "enum" + namesCompletionItemKind[int(KeywordCompletion)] = "keyword" + namesCompletionItemKind[int(SnippetCompletion)] = "snippet" + namesCompletionItemKind[int(ColorCompletion)] = "color" + namesCompletionItemKind[int(FileCompletion)] = "file" + namesCompletionItemKind[int(ReferenceCompletion)] = "reference" + namesCompletionItemKind[int(FolderCompletion)] = "folder" + namesCompletionItemKind[int(EnumMemberCompletion)] = "enumMember" + namesCompletionItemKind[int(ConstantCompletion)] = "const" + namesCompletionItemKind[int(StructCompletion)] = "struct" + namesCompletionItemKind[int(EventCompletion)] = "event" + namesCompletionItemKind[int(OperatorCompletion)] = "operator" + namesCompletionItemKind[int(TypeParameterCompletion)] = "typeParam" + + namesInsertTextFormat[int(PlainTextTextFormat)] = "PlainText" + namesInsertTextFormat[int(SnippetTextFormat)] = "Snippet" + + namesDocumentHighlightKind[int(Text)] = "Text" + namesDocumentHighlightKind[int(Read)] = "Read" + namesDocumentHighlightKind[int(Write)] = "Write" + + namesSymbolKind[int(File)] = "File" + namesSymbolKind[int(Module)] = "Module" + namesSymbolKind[int(Namespace)] = "Namespace" + namesSymbolKind[int(Package)] = "Package" + namesSymbolKind[int(Class)] = "Class" + namesSymbolKind[int(Method)] = "Method" + namesSymbolKind[int(Property)] = "Property" + namesSymbolKind[int(Field)] = "Field" + namesSymbolKind[int(Constructor)] = "Constructor" + namesSymbolKind[int(Enum)] = "Enum" + namesSymbolKind[int(Interface)] = "Interface" + namesSymbolKind[int(Function)] = "Function" + namesSymbolKind[int(Variable)] = "Variable" + namesSymbolKind[int(Constant)] = "Constant" + namesSymbolKind[int(String)] = "String" + namesSymbolKind[int(Number)] = "Number" + namesSymbolKind[int(Boolean)] = "Boolean" + namesSymbolKind[int(Array)] = "Array" + namesSymbolKind[int(Object)] = "Object" + namesSymbolKind[int(Key)] = "Key" + namesSymbolKind[int(Null)] = "Null" + namesSymbolKind[int(EnumMember)] = "EnumMember" + namesSymbolKind[int(Struct)] = "Struct" + namesSymbolKind[int(Event)] = "Event" + namesSymbolKind[int(Operator)] = "Operator" + namesSymbolKind[int(TypeParameter)] = "TypeParameter" + + namesTextDocumentSaveReason[int(Manual)] = "Manual" + namesTextDocumentSaveReason[int(AfterDelay)] = "AfterDelay" + namesTextDocumentSaveReason[int(FocusOut)] = "FocusOut" +} + +func formatEnum(f fmt.State, c rune, i int, names []string, unknown string) { + s := "" + if i >= 0 && i < len(names) { + s = names[i] + } + if s != "" { + fmt.Fprint(f, s) + } else { + fmt.Fprintf(f, "%s(%d)", unknown, i) + } +} + +func parseEnum(s string, names []string) int { + for i, name := range names { + if s == name { + return i + } + } + return 0 +} + +func (e TextDocumentSyncKind) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesTextDocumentSyncKind[:], "TextDocumentSyncKind") +} + +func ParseTextDocumentSyncKind(s string) TextDocumentSyncKind { + return TextDocumentSyncKind(parseEnum(s, namesTextDocumentSyncKind[:])) +} + +func (e MessageType) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesMessageType[:], "MessageType") +} + +func ParseMessageType(s string) MessageType { + return MessageType(parseEnum(s, namesMessageType[:])) +} + +func (e FileChangeType) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesFileChangeType[:], "FileChangeType") +} + +func ParseFileChangeType(s string) FileChangeType { + return FileChangeType(parseEnum(s, namesFileChangeType[:])) +} + +func ParseWatchKind(s string) WatchKind { + return WatchKind(parseEnum(s, namesWatchKind[:])) +} + +func (e CompletionTriggerKind) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesCompletionTriggerKind[:], "CompletionTriggerKind") +} + +func ParseCompletionTriggerKind(s string) CompletionTriggerKind { + return CompletionTriggerKind(parseEnum(s, namesCompletionTriggerKind[:])) +} + +func (e DiagnosticSeverity) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesDiagnosticSeverity[:], "DiagnosticSeverity") +} + +func ParseDiagnosticSeverity(s string) DiagnosticSeverity { + return DiagnosticSeverity(parseEnum(s, namesDiagnosticSeverity[:])) +} + +func (e DiagnosticTag) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesDiagnosticTag[:], "DiagnosticTag") +} + +func ParseDiagnosticTag(s string) DiagnosticTag { + return DiagnosticTag(parseEnum(s, namesDiagnosticTag[:])) +} + +func (e CompletionItemKind) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesCompletionItemKind[:], "CompletionItemKind") +} + +func ParseCompletionItemKind(s string) CompletionItemKind { + return CompletionItemKind(parseEnum(s, namesCompletionItemKind[:])) +} + +func (e InsertTextFormat) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesInsertTextFormat[:], "InsertTextFormat") +} + +func ParseInsertTextFormat(s string) InsertTextFormat { + return InsertTextFormat(parseEnum(s, namesInsertTextFormat[:])) +} + +func (e DocumentHighlightKind) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesDocumentHighlightKind[:], "DocumentHighlightKind") +} + +func ParseDocumentHighlightKind(s string) DocumentHighlightKind { + return DocumentHighlightKind(parseEnum(s, namesDocumentHighlightKind[:])) +} + +func (e SymbolKind) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesSymbolKind[:], "SymbolKind") +} + +func ParseSymbolKind(s string) SymbolKind { + return SymbolKind(parseEnum(s, namesSymbolKind[:])) +} + +func (e TextDocumentSaveReason) Format(f fmt.State, c rune) { + formatEnum(f, c, int(e), namesTextDocumentSaveReason[:], "TextDocumentSaveReason") +} + +func ParseTextDocumentSaveReason(s string) TextDocumentSaveReason { + return TextDocumentSaveReason(parseEnum(s, namesTextDocumentSaveReason[:])) +} diff --git a/gopls/internal/lsp/protocol/generate/README.md b/gopls/internal/lsp/protocol/generate/README.md new file mode 100644 index 000000000..c8047f32b --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/README.md @@ -0,0 +1,136 @@ +# LSP Support for gopls + +## The protocol + +The LSP protocol exchanges json-encoded messages between the client and the server. +(gopls is the server.) The messages are either Requests, which require Responses, or +Notifications, which generate no response. Each Request or Notification has a method name +such as "textDocument/hover" that indicates its meaning and determines which function in the server will handle it. +The protocol is described in a +[web page](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.18/specification/), +in words, and in a json file (metaModel.json) available either linked towards the bottom of the +web page, or in the vscode-languageserver-node repository. This code uses the latter so the +exact version can be tied to a githash. By default, the command will download the `github.com/microsoft/vscode-languageserver-node` repository to a temporary directory. + +The specification has five sections +1. Requests, which describe the Request and Response types for request methods (e.g., *textDocument/didChange*), +2. Notifications, which describe the Request types for notification methods, +3. Structures, which describe named struct-like types, +4. TypeAliases, which describe type aliases, +5. Enumerations, which describe named constants. + +Requests and Notifications are tagged with a Method (e.g., `"textDocument/hover"`). +The specification does not specify the names of the functions that handle the messages. These +names are specified by the `methodNames` map. Enumerations generate Go `const`s, but +in Typescript they are scoped to namespaces, while in Go they are scoped to a package, so the Go names +may need to be modified to avoid name collisions. (See the `disambiguate` map, and its use.) + +Finally, the specified types are Typescript types, which are quite different from Go types. + +### Optionality +The specification can mark fields in structs as Optional. The client distinguishes between missing +fields and `null` fields in some cases. The Go translation for an optional type +should be making sure the field's value +can be `nil`, and adding the json tag `,omitempty`. The former condition would be satisfied by +adding `*` to the field's type if the type is not a reference type. + +### Types +The specification uses a number of different types, only a few of which correspond directly to Go types. +The specification's types are "base", "reference", "map", "literal", "stringLiteral", "tuple", "and", "or". +The "base" types correspond directly to Go types, although some Go types needs to be chosen for `URI` and `DocumentUri`. (The "base" types`RegExp`, `BooleanLiteral`, `NumericLiteral` never occur.) + +"reference" types are the struct-like types in the Structures section of the specification. The given +names are suitable for Go to use, except the code needs to change names like `_Initialze` to `XInitialize` so +they are exported for json marshaling and unmarshaling. + +"map" types are just like Go. (The key type in all of them is `DocumentUri`.) + +"stringLiteral" types are types whose type name and value are a single string. The chosen Go equivalent +is to make the type `string` and the value a constant. (The alternative would be to generate a new +named type, which seemed redundant.) + +"literal" types are like Go anonymous structs, so they have to be given a name. (All instances +of the remaining types have to be given names. One approach is to construct the name from the components +of the type, but this leads to misleading punning, and is unstable if components are added. The other approach +is to construct the name from the context of the definition, that is, from the types it is defined within. +For instance `Lit__InitializeParams_clientInfo` is the "literal" type at the +`clientInfo` field in the `_InitializeParams` +struct. Although this choice is sensitive to the ordering of the components, the code uses this approach, +presuming that reordering components is an unlikely protocol change.) + +"tuple" types are generated as Go structs. (There is only one, with two `uint32` fields.) + +"and" types are Go structs with embedded type names. (There is only one, `And_Param_workspace_configuration`.) + +"or" types are the most complicated. There are a lot of them and there is no simple Go equivalent. +They are defined as structs with a single `Value interface{}` field and custom json marshaling +and unmarshaling code. Users can assign anything to `Value` but the type will be checked, and +correctly marshaled, by the custom marshaling code. The unmarshaling code checks types, so `Value` +will have one of the permitted types. (`nil` is always allowed.) There are about 40 "or" types that +have a single non-null component, and these are converted to the component type. + +## Processing +The code parses the json specification file, and scans all the types. It assigns names, as described +above, to the types that are unnamed in the specification, and constructs Go equivalents as required. +(Most of this code is in typenames.go.) + +There are four output files. tsclient.go and tsserver.go contain the definition and implementation +of the `protocol.Client` and `protocol.Server` types and the code that dispatches on the Method +of the Request or Notification. tsjson.go contains the custom marshaling and unmarshaling code. +And tsprotocol.go contains the type and const definitions. + +### Accommodating gopls +As the code generates output, mostly in generateoutput.go and main.go, +it makes adjustments so that no changes are required to the existing Go code. +(Organizing the computation this way makes the code's structure simpler, but results in +a lot of unused types.) +There are three major classes of these adjustments, and leftover special cases. + +The first major +adjustment is to change generated type names to the ones gopls expects. Some of these don't change the +semantics of the type, just the name. +But for historical reasons a lot of them replace "or" types by a single +component of the type. (Until fairly recently Go only saw or used only one of components.) +The `goplsType` map in tables.go controls this process. + +The second major adjustment is to the types of fields of structs, which is done using the +`renameProp` map in tables.go. + +The third major adjustment handles optionality, controlling `*` and `,omitempty` placement when +the default rules don't match what gopls is expecting. (The map is `goplsStar`, also in tables.go) +(If the intermediate components in expressions of the form `A.B.C.S` were optional, the code would need +a lot of useless checking for nils. Typescript has a language construct to avoid most checks.) + +Then there are some additional special cases. There are a few places with adjustments to avoid +recursive types. For instance `LSPArray` is `[]LSPAny`, but `LSPAny` is an "or" type including `LSPArray`. +The solution is to make `LSPAny` an `interface{}`. Another instance is `_InitializeParams.trace` +whose type is an "or" of 3 stringLiterals, which just becomes a `string`. + +### Checking +`TestAll(t *testing.T)` checks that there are no unexpected fields in the json specification. + +While the code is executing, it checks that all the entries in the maps in tables.go are used. +It also checks that the entries in `renameProp` and `goplsStar` are not redundant. + +As a one-time check on the first release of this code, diff-ing the existing and generated tsclient.go +and tsserver.go code results in only whitespace and comment diffs. The existing and generated +tsprotocol.go differ in whitespace and comments, and in a substantial number of new type definitions +that the older, more heuristic, code did not generate. (And the unused type `_InitializeParams` differs +slightly between the new and the old, and is not worth fixing.) + +### Some history +The original stub code was written by hand, but with the protocol under active development, that +couldn't last. The web page existed before the json specification, but it lagged the implementation +and was hard to process by machine. So the earlier version of the generating code was written in Typescript, and +used the Typescript compiler's API to parse the protocol code in the repository. +It then used a set of heuristics +to pick out the elements of the protocol, and another set of overlapping heuristics to create the Go code. +The output was functional, but idiosyncratic, and the code was fragile and barely maintainable. + +### The future +Most of the adjustments using the maps in tables.go could be removed by making changes, mostly to names, +in the gopls code. Using more "or" types in gopls requires more elaborate, but stereotyped, changes. +But even without all the adjustments, making this its own module would face problems; a number of +dependencies would have to be factored out. And, it is fragile. The custom unmarshaling code knows what +types it expects. A design that return an 'any' on unexpected types would match the json +'ignore unexpected values' philosophy better, but the the Go code would need extra checking. diff --git a/gopls/internal/lsp/protocol/generate/generate.go b/gopls/internal/lsp/protocol/generate/generate.go new file mode 100644 index 000000000..0496b7d06 --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/generate.go @@ -0,0 +1,121 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +package main + +import ( + "bytes" + "fmt" + "log" + "strings" +) + +// a newType is a type that needs a name and a definition +// These are the various types that the json specification doesn't name +type newType struct { + name string + properties Properties // for struct/literal types + items []*Type // for other types ("and", "tuple") + line int + kind string // Or, And, Tuple, Lit, Map + typ *Type +} + +func generateDoc(out *bytes.Buffer, doc string) { + if doc == "" { + return + } + + if !strings.Contains(doc, "\n") { + fmt.Fprintf(out, "// %s\n", doc) + return + } + var list bool + for _, line := range strings.Split(doc, "\n") { + // Lists in metaModel.json start with a dash. + // To make a go doc list they have to be preceded + // by a blank line, and indented. + // (see type TextDccumentFilter in protocol.go) + if len(line) > 0 && line[0] == '-' { + if !list { + list = true + fmt.Fprintf(out, "//\n") + } + fmt.Fprintf(out, "// %s\n", line) + } else { + if len(line) == 0 { + list = false + } + fmt.Fprintf(out, "// %s\n", line) + } + } +} + +// decide if a property is optional, and if it needs a * +// return ",omitempty" if it is optional, and "*" if it needs a pointer +func propStar(name string, t NameType, gotype string) (string, string) { + var opt, star string + if t.Optional { + star = "*" + opt = ",omitempty" + } + if strings.HasPrefix(gotype, "[]") || strings.HasPrefix(gotype, "map[") { + star = "" // passed by reference, so no need for * + } else { + switch gotype { + case "bool", "uint32", "int32", "string", "interface{}": + star = "" // gopls compatibility if t.Optional + } + } + ostar, oopt := star, opt + if newStar, ok := goplsStar[prop{name, t.Name}]; ok { + switch newStar { + case nothing: + star, opt = "", "" + case wantStar: + star, opt = "*", "" + case wantOpt: + star, opt = "", ",omitempty" + case wantOptStar: + star, opt = "*", ",omitempty" + } + if star == ostar && opt == oopt { // no change + log.Printf("goplsStar[ {%q, %q} ](%d) useless %s/%s %s/%s", name, t.Name, t.Line, ostar, star, oopt, opt) + } + usedGoplsStar[prop{name, t.Name}] = true + } + + return opt, star +} + +func goName(s string) string { + // Go naming conventions + if strings.HasSuffix(s, "Id") { + s = s[:len(s)-len("Id")] + "ID" + } else if strings.HasSuffix(s, "Uri") { + s = s[:len(s)-3] + "URI" + } else if s == "uri" { + s = "URI" + } else if s == "id" { + s = "ID" + } + + // renames for temporary GOPLS compatibility + if news := goplsType[s]; news != "" { + usedGoplsType[s] = true + s = news + } + // Names beginning _ are not exported + if strings.HasPrefix(s, "_") { + s = strings.Replace(s, "_", "X", 1) + } + if s != "string" { // base types are unchanged (textDocuemnt/diagnostic) + // Title is deprecated, but a) s is only one word, b) replacement is too heavy-weight + s = strings.Title(s) + } + return s +} diff --git a/gopls/internal/lsp/protocol/generate/main.go b/gopls/internal/lsp/protocol/generate/main.go new file mode 100644 index 000000000..d1114911e --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/main.go @@ -0,0 +1,387 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +// The generate command generates Go declarations from VSCode's +// description of the Language Server Protocol. +// +// To run it, type 'go generate' in the parent (protocol) directory. +package main + +import ( + "bytes" + "encoding/json" + "flag" + "fmt" + "go/format" + "log" + "os" + "os/exec" + "path/filepath" + "strings" +) + +const vscodeRepo = "https://github.com/microsoft/vscode-languageserver-node" + +// lspGitRef names a branch or tag in vscodeRepo. +// It implicitly determines the protocol version of the LSP used by gopls. +// For example, tag release/protocol/3.17.3 of the repo defines protocol version 3.17.0. +// (Point releases are reflected in the git tag version even when they are cosmetic +// and don't change the protocol.) +var lspGitRef = "release/protocol/3.17.3-next.6" + +var ( + repodir = flag.String("d", "", "directory containing clone of "+vscodeRepo) + outputdir = flag.String("o", ".", "output directory") + // PJW: not for real code + cmpdir = flag.String("c", "", "directory of earlier code") + doboth = flag.String("b", "", "generate and compare") +) + +func main() { + log.SetFlags(log.Lshortfile) // log file name and line number, not time + flag.Parse() + + processinline() +} + +func processinline() { + // A local repository may be specified during debugging. + // The default behavior is to download the canonical version. + if *repodir == "" { + tmpdir, err := os.MkdirTemp("", "") + if err != nil { + log.Fatal(err) + } + defer os.RemoveAll(tmpdir) // ignore error + + // Clone the repository. + cmd := exec.Command("git", "clone", "--quiet", "--depth=1", "-c", "advice.detachedHead=false", vscodeRepo, "--branch="+lspGitRef, "--single-branch", tmpdir) + cmd.Stdout = os.Stderr + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + log.Fatal(err) + } + + *repodir = tmpdir + } else { + lspGitRef = fmt.Sprintf("(not git, local dir %s)", *repodir) + } + + model := parse(filepath.Join(*repodir, "protocol/metaModel.json")) + + findTypeNames(model) + generateOutput(model) + + fileHdr = fileHeader(model) + + // write the files + writeclient() + writeserver() + writeprotocol() + writejsons() + + checkTables() +} + +// common file header for output files +var fileHdr string + +func writeclient() { + out := new(bytes.Buffer) + fmt.Fprintln(out, fileHdr) + out.WriteString( + `import ( + "context" + "encoding/json" + + "golang.org/x/tools/internal/jsonrpc2" +) +`) + out.WriteString("type Client interface {\n") + for _, k := range cdecls.keys() { + out.WriteString(cdecls[k]) + } + out.WriteString("}\n\n") + out.WriteString("func clientDispatch(ctx context.Context, client Client, reply jsonrpc2.Replier, r jsonrpc2.Request) (bool, error) {\n") + out.WriteString("\tswitch r.Method() {\n") + for _, k := range ccases.keys() { + out.WriteString(ccases[k]) + } + out.WriteString(("\tdefault:\n\t\treturn false, nil\n\t}\n}\n\n")) + for _, k := range cfuncs.keys() { + out.WriteString(cfuncs[k]) + } + + x, err := format.Source(out.Bytes()) + if err != nil { + os.WriteFile("/tmp/a.go", out.Bytes(), 0644) + log.Fatalf("tsclient.go: %v", err) + } + + if err := os.WriteFile(filepath.Join(*outputdir, "tsclient.go"), x, 0644); err != nil { + log.Fatalf("%v writing tsclient.go", err) + } +} + +func writeserver() { + out := new(bytes.Buffer) + fmt.Fprintln(out, fileHdr) + out.WriteString( + `import ( + "context" + "encoding/json" + + "golang.org/x/tools/internal/jsonrpc2" +) +`) + out.WriteString("type Server interface {\n") + for _, k := range sdecls.keys() { + out.WriteString(sdecls[k]) + } + out.WriteString(` NonstandardRequest(ctx context.Context, method string, params interface{}) (interface{}, error) +} + +func serverDispatch(ctx context.Context, server Server, reply jsonrpc2.Replier, r jsonrpc2.Request) (bool, error) { + switch r.Method() { +`) + for _, k := range scases.keys() { + out.WriteString(scases[k]) + } + out.WriteString(("\tdefault:\n\t\treturn false, nil\n\t}\n}\n\n")) + for _, k := range sfuncs.keys() { + out.WriteString(sfuncs[k]) + } + out.WriteString(`func (s *serverDispatcher) NonstandardRequest(ctx context.Context, method string, params interface{}) (interface{}, error) { + var result interface{} + if err := s.sender.Call(ctx, method, params, &result); err != nil { + return nil, err + } + return result, nil +} +`) + + x, err := format.Source(out.Bytes()) + if err != nil { + os.WriteFile("/tmp/a.go", out.Bytes(), 0644) + log.Fatalf("tsserver.go: %v", err) + } + + if err := os.WriteFile(filepath.Join(*outputdir, "tsserver.go"), x, 0644); err != nil { + log.Fatalf("%v writing tsserver.go", err) + } +} + +func writeprotocol() { + out := new(bytes.Buffer) + fmt.Fprintln(out, fileHdr) + out.WriteString("import \"encoding/json\"\n\n") + + // The followiing are unneeded, but make the new code a superset of the old + hack := func(newer, existing string) { + if _, ok := types[existing]; !ok { + log.Fatalf("types[%q] not found", existing) + } + types[newer] = strings.Replace(types[existing], existing, newer, 1) + } + hack("ConfigurationParams", "ParamConfiguration") + hack("InitializeParams", "ParamInitialize") + hack("PreviousResultId", "PreviousResultID") + hack("WorkspaceFoldersServerCapabilities", "WorkspaceFolders5Gn") + hack("_InitializeParams", "XInitializeParams") + // and some aliases to make the new code contain the old + types["PrepareRename2Gn"] = "type PrepareRename2Gn = Msg_PrepareRename2Gn // (alias) line 13927\n" + types["PrepareRenameResult"] = "type PrepareRenameResult = Msg_PrepareRename2Gn // (alias) line 13927\n" + for _, k := range types.keys() { + if k == "WatchKind" { + types[k] = "type WatchKind = uint32 // line 13505" // strict gopls compatibility needs the '=' + } + out.WriteString(types[k]) + } + + out.WriteString("\nconst (\n") + for _, k := range consts.keys() { + out.WriteString(consts[k]) + } + out.WriteString(")\n\n") + x, err := format.Source(out.Bytes()) + if err != nil { + os.WriteFile("/tmp/a.go", out.Bytes(), 0644) + log.Fatalf("tsprotocol.go: %v", err) + } + if err := os.WriteFile(filepath.Join(*outputdir, "tsprotocol.go"), x, 0644); err != nil { + log.Fatalf("%v writing tsprotocol.go", err) + } +} + +func writejsons() { + out := new(bytes.Buffer) + fmt.Fprintln(out, fileHdr) + out.WriteString("import \"encoding/json\"\n\n") + out.WriteString("import \"fmt\"\n") + + out.WriteString(` +// UnmarshalError indicates that a JSON value did not conform to +// one of the expected cases of an LSP union type. +type UnmarshalError struct { + msg string +} + +func (e UnmarshalError) Error() string { + return e.msg +} +`) + + for _, k := range jsons.keys() { + out.WriteString(jsons[k]) + } + x, err := format.Source(out.Bytes()) + if err != nil { + os.WriteFile("/tmp/a.go", out.Bytes(), 0644) + log.Fatalf("tsjson.go: %v", err) + } + if err := os.WriteFile(filepath.Join(*outputdir, "tsjson.go"), x, 0644); err != nil { + log.Fatalf("%v writing tsjson.go", err) + } +} + +// create the common file header for the output files +func fileHeader(model Model) string { + fname := filepath.Join(*repodir, ".git", "HEAD") + buf, err := os.ReadFile(fname) + if err != nil { + log.Fatal(err) + } + buf = bytes.TrimSpace(buf) + var githash string + if len(buf) == 40 { + githash = string(buf[:40]) + } else if bytes.HasPrefix(buf, []byte("ref: ")) { + fname = filepath.Join(*repodir, ".git", string(buf[5:])) + buf, err = os.ReadFile(fname) + if err != nil { + log.Fatal(err) + } + githash = string(buf[:40]) + } else { + log.Fatalf("githash cannot be recovered from %s", fname) + } + + format := `// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated for LSP. DO NOT EDIT. + +package protocol + +// Code generated from %[1]s at ref %[2]s (hash %[3]s). +// %[4]s/blob/%[2]s/%[1]s +// LSP metaData.version = %[5]s. + +` + return fmt.Sprintf(format, + "protocol/metaModel.json", // 1 + lspGitRef, // 2 + githash, // 3 + vscodeRepo, // 4 + model.Version.Version) // 5 +} + +func parse(fname string) Model { + buf, err := os.ReadFile(fname) + if err != nil { + log.Fatal(err) + } + buf = addLineNumbers(buf) + var model Model + if err := json.Unmarshal(buf, &model); err != nil { + log.Fatal(err) + } + return model +} + +// Type.Value has to be treated specially for literals and maps +func (t *Type) UnmarshalJSON(data []byte) error { + // First unmarshal only the unambiguous fields. + var x struct { + Kind string `json:"kind"` + Items []*Type `json:"items"` + Element *Type `json:"element"` + Name string `json:"name"` + Key *Type `json:"key"` + Value any `json:"value"` + Line int `json:"line"` + } + if err := json.Unmarshal(data, &x); err != nil { + return err + } + *t = Type{ + Kind: x.Kind, + Items: x.Items, + Element: x.Element, + Name: x.Name, + Value: x.Value, + Line: x.Line, + } + + // Then unmarshal the 'value' field based on the kind. + // This depends on Unmarshal ignoring fields it doesn't know about. + switch x.Kind { + case "map": + var x struct { + Key *Type `json:"key"` + Value *Type `json:"value"` + } + if err := json.Unmarshal(data, &x); err != nil { + return fmt.Errorf("Type.kind=map: %v", err) + } + t.Key = x.Key + t.Value = x.Value + + case "literal": + var z struct { + Value ParseLiteral `json:"value"` + } + + if err := json.Unmarshal(data, &z); err != nil { + return fmt.Errorf("Type.kind=literal: %v", err) + } + t.Value = z.Value + + case "base", "reference", "array", "and", "or", "tuple", + "stringLiteral": + // no-op. never seen integerLiteral or booleanLiteral. + + default: + return fmt.Errorf("cannot decode Type.kind %q: %s", x.Kind, data) + } + return nil +} + +// which table entries were not used +func checkTables() { + for k := range disambiguate { + if !usedDisambiguate[k] { + log.Printf("disambiguate[%v] unused", k) + } + } + for k := range renameProp { + if !usedRenameProp[k] { + log.Printf("renameProp {%q, %q} unused", k[0], k[1]) + } + } + for k := range goplsStar { + if !usedGoplsStar[k] { + log.Printf("goplsStar {%q, %q} unused", k[0], k[1]) + } + } + for k := range goplsType { + if !usedGoplsType[k] { + log.Printf("unused goplsType[%q]->%s", k, goplsType[k]) + } + } +} diff --git a/gopls/internal/lsp/protocol/generate/main_test.go b/gopls/internal/lsp/protocol/generate/main_test.go new file mode 100644 index 000000000..f887066ee --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/main_test.go @@ -0,0 +1,118 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +package main + +import ( + "encoding/json" + "fmt" + "log" + "os" + "testing" +) + +// These tests require the result of +//"git clone https://github.com/microsoft/vscode-languageserver-node" in the HOME directory + +// this is not a test, but a way to get code coverage, +// (in vscode, just run the test with "go.coverOnSingleTest": true) +func TestAll(t *testing.T) { + t.Skip("needs vscode-languageserver-node repository") + log.SetFlags(log.Lshortfile) + main() +} + +// check that the parsed file includes all the information +// from the json file. This test will fail if the spec +// introduces new fields. (one can test this test by +// commenting out the version field in Model.) +func TestParseContents(t *testing.T) { + t.Skip("needs vscode-languageserver-node repository") + log.SetFlags(log.Lshortfile) + + // compute our parse of the specification + dir := os.Getenv("HOME") + "/vscode-languageserver-node" + fname := dir + "/protocol/metaModel.json" + v := parse(fname) + out, err := json.Marshal(v) + if err != nil { + t.Fatal(err) + } + var our interface{} + if err := json.Unmarshal(out, &our); err != nil { + t.Fatal(err) + } + + // process the json file + buf, err := os.ReadFile(fname) + if err != nil { + t.Fatalf("could not read metaModel.json: %v", err) + } + var raw interface{} + if err := json.Unmarshal(buf, &raw); err != nil { + t.Fatal(err) + } + + // convert to strings showing the fields + them := flatten(raw) + us := flatten(our) + + // everything in them should be in us + lesser := make(sortedMap[bool]) + for _, s := range them { + lesser[s] = true + } + greater := make(sortedMap[bool]) // set of fields we have + for _, s := range us { + greater[s] = true + } + for _, k := range lesser.keys() { // set if fields they have + if !greater[k] { + t.Errorf("missing %s", k) + } + } +} + +// flatten(nil) = "nil" +// flatten(v string) = fmt.Sprintf("%q", v) +// flatten(v float64)= fmt.Sprintf("%g", v) +// flatten(v bool) = fmt.Sprintf("%v", v) +// flatten(v []any) = []string{"[0]"flatten(v[0]), "[1]"flatten(v[1]), ...} +// flatten(v map[string]any) = {"key1": flatten(v["key1"]), "key2": flatten(v["key2"]), ...} +func flatten(x any) []string { + switch v := x.(type) { + case nil: + return []string{"nil"} + case string: + return []string{fmt.Sprintf("%q", v)} + case float64: + return []string{fmt.Sprintf("%g", v)} + case bool: + return []string{fmt.Sprintf("%v", v)} + case []any: + var ans []string + for i, x := range v { + idx := fmt.Sprintf("[%.3d]", i) + for _, s := range flatten(x) { + ans = append(ans, idx+s) + } + } + return ans + case map[string]any: + var ans []string + for k, x := range v { + idx := fmt.Sprintf("%q:", k) + for _, s := range flatten(x) { + ans = append(ans, idx+s) + } + } + return ans + default: + log.Fatalf("unexpected type %T", x) + return nil + } +} diff --git a/gopls/internal/lsp/protocol/generate/output.go b/gopls/internal/lsp/protocol/generate/output.go new file mode 100644 index 000000000..18dd6ea3f --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/output.go @@ -0,0 +1,420 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +package main + +import ( + "bytes" + "fmt" + "log" + "sort" + "strings" +) + +var ( + // tsclient.go has 3 sections + cdecls = make(sortedMap[string]) + ccases = make(sortedMap[string]) + cfuncs = make(sortedMap[string]) + // tsserver.go has 3 sections + sdecls = make(sortedMap[string]) + scases = make(sortedMap[string]) + sfuncs = make(sortedMap[string]) + // tsprotocol.go has 2 sections + types = make(sortedMap[string]) + consts = make(sortedMap[string]) + // tsjson has 1 section + jsons = make(sortedMap[string]) +) + +func generateOutput(model Model) { + for _, r := range model.Requests { + genDecl(r.Method, r.Params, r.Result, r.Direction) + genCase(r.Method, r.Params, r.Result, r.Direction) + genFunc(r.Method, r.Params, r.Result, r.Direction, false) + } + for _, n := range model.Notifications { + if n.Method == "$/cancelRequest" { + continue // handled internally by jsonrpc2 + } + genDecl(n.Method, n.Params, nil, n.Direction) + genCase(n.Method, n.Params, nil, n.Direction) + genFunc(n.Method, n.Params, nil, n.Direction, true) + } + genStructs(model) + genAliases(model) + genGenTypes() // generate the unnamed types + genConsts(model) + genMarshal() +} + +func genDecl(method string, param, result *Type, dir string) { + fname := methodNames[method] + p := "" + if notNil(param) { + p = ", *" + goplsName(param) + } + ret := "error" + if notNil(result) { + tp := goplsName(result) + if !hasNilValue(tp) { + tp = "*" + tp + } + ret = fmt.Sprintf("(%s, error)", tp) + } + // special gopls compatibility case (PJW: still needed?) + switch method { + case "workspace/configuration": + // was And_Param_workspace_configuration, but the type substitution doesn't work, + // as ParamConfiguration is embedded in And_Param_workspace_configuration + p = ", *ParamConfiguration" + ret = "([]LSPAny, error)" + } + msg := fmt.Sprintf("\t%s(context.Context%s) %s // %s\n", fname, p, ret, method) + switch dir { + case "clientToServer": + sdecls[method] = msg + case "serverToClient": + cdecls[method] = msg + case "both": + sdecls[method] = msg + cdecls[method] = msg + default: + log.Fatalf("impossible direction %q", dir) + } +} + +func genCase(method string, param, result *Type, dir string) { + out := new(bytes.Buffer) + fmt.Fprintf(out, "\tcase %q:\n", method) + var p string + fname := methodNames[method] + if notNil(param) { + nm := goplsName(param) + if method == "workspace/configuration" { // gopls compatibility + // was And_Param_workspace_configuration, which contains ParamConfiguration + // so renaming the type leads to circular definitions + nm = "ParamConfiguration" // gopls compatibility + } + fmt.Fprintf(out, "\t\tvar params %s\n", nm) + fmt.Fprintf(out, "\t\tif err := json.Unmarshal(r.Params(), ¶ms); err != nil {\n") + fmt.Fprintf(out, "\t\t\treturn true, sendParseError(ctx, reply, err)\n\t\t}\n") + p = ", ¶ms" + } + if notNil(result) { + fmt.Fprintf(out, "\t\tresp, err := %%s.%s(ctx%s)\n", fname, p) + out.WriteString("\t\tif err != nil {\n") + out.WriteString("\t\t\treturn true, reply(ctx, nil, err)\n") + out.WriteString("\t\t}\n") + out.WriteString("\t\treturn true, reply(ctx, resp, nil)\n") + } else { + fmt.Fprintf(out, "\t\terr := %%s.%s(ctx%s)\n", fname, p) + out.WriteString("\t\treturn true, reply(ctx, nil, err)\n") + } + msg := out.String() + switch dir { + case "clientToServer": + scases[method] = fmt.Sprintf(msg, "server") + case "serverToClient": + ccases[method] = fmt.Sprintf(msg, "client") + case "both": + scases[method] = fmt.Sprintf(msg, "server") + ccases[method] = fmt.Sprintf(msg, "client") + default: + log.Fatalf("impossible direction %q", dir) + } +} + +func genFunc(method string, param, result *Type, dir string, isnotify bool) { + out := new(bytes.Buffer) + var p, r string + var goResult string + if notNil(param) { + p = ", params *" + goplsName(param) + } + if notNil(result) { + goResult = goplsName(result) + if !hasNilValue(goResult) { + goResult = "*" + goResult + } + r = fmt.Sprintf("(%s, error)", goResult) + } else { + r = "error" + } + // special gopls compatibility case + switch method { + case "workspace/configuration": + // was And_Param_workspace_configuration, but the type substitution doesn't work, + // as ParamConfiguration is embedded in And_Param_workspace_configuration + p = ", params *ParamConfiguration" + r = "([]LSPAny, error)" + goResult = "[]LSPAny" + } + fname := methodNames[method] + fmt.Fprintf(out, "func (s *%%sDispatcher) %s(ctx context.Context%s) %s {\n", + fname, p, r) + + if !notNil(result) { + if isnotify { + if notNil(param) { + fmt.Fprintf(out, "\treturn s.sender.Notify(ctx, %q, params)\n", method) + } else { + fmt.Fprintf(out, "\treturn s.sender.Notify(ctx, %q, nil)\n", method) + } + } else { + if notNil(param) { + fmt.Fprintf(out, "\treturn s.sender.Call(ctx, %q, params, nil)\n", method) + } else { + fmt.Fprintf(out, "\treturn s.sender.Call(ctx, %q, nil, nil)\n", method) + } + } + } else { + fmt.Fprintf(out, "\tvar result %s\n", goResult) + if isnotify { + if notNil(param) { + fmt.Fprintf(out, "\ts.sender.Notify(ctx, %q, params)\n", method) + } else { + fmt.Fprintf(out, "\t\tif err := s.sender.Notify(ctx, %q, nil); err != nil {\n", method) + } + } else { + if notNil(param) { + fmt.Fprintf(out, "\t\tif err := s.sender.Call(ctx, %q, params, &result); err != nil {\n", method) + } else { + fmt.Fprintf(out, "\t\tif err := s.sender.Call(ctx, %q, nil, &result); err != nil {\n", method) + } + } + fmt.Fprintf(out, "\t\treturn nil, err\n\t}\n\treturn result, nil\n") + } + out.WriteString("}\n") + msg := out.String() + switch dir { + case "clientToServer": + sfuncs[method] = fmt.Sprintf(msg, "server") + case "serverToClient": + cfuncs[method] = fmt.Sprintf(msg, "client") + case "both": + sfuncs[method] = fmt.Sprintf(msg, "server") + cfuncs[method] = fmt.Sprintf(msg, "client") + default: + log.Fatalf("impossible direction %q", dir) + } +} + +func genStructs(model Model) { + structures := make(map[string]*Structure) // for expanding Extends + for _, s := range model.Structures { + structures[s.Name] = s + } + for _, s := range model.Structures { + out := new(bytes.Buffer) + generateDoc(out, s.Documentation) + nm := goName(s.Name) + if nm == "string" { // an unacceptable strut name + // a weird case, and needed only so the generated code contains the old gopls code + nm = "DocumentDiagnosticParams" + } + fmt.Fprintf(out, "type %s struct { // line %d\n", nm, s.Line) + // for gpls compatibilitye, embed most extensions, but expand the rest some day + props := append([]NameType{}, s.Properties...) + if s.Name == "SymbolInformation" { // but expand this one + for _, ex := range s.Extends { + fmt.Fprintf(out, "\t// extends %s\n", ex.Name) + props = append(props, structures[ex.Name].Properties...) + } + genProps(out, props, nm) + } else { + genProps(out, props, nm) + for _, ex := range s.Extends { + fmt.Fprintf(out, "\t%s\n", goName(ex.Name)) + } + } + for _, ex := range s.Mixins { + fmt.Fprintf(out, "\t%s\n", goName(ex.Name)) + } + out.WriteString("}\n") + types[nm] = out.String() + } + // base types + types["DocumentURI"] = "type DocumentURI string\n" + types["URI"] = "type URI = string\n" + + types["LSPAny"] = "type LSPAny = interface{}\n" + // A special case, the only previously existing Or type + types["DocumentDiagnosticReport"] = "type DocumentDiagnosticReport = Or_DocumentDiagnosticReport // (alias) line 13909\n" + +} + +func genProps(out *bytes.Buffer, props []NameType, name string) { + for _, p := range props { + tp := goplsName(p.Type) + if newNm, ok := renameProp[prop{name, p.Name}]; ok { + usedRenameProp[prop{name, p.Name}] = true + if tp == newNm { + log.Printf("renameProp useless {%q, %q} for %s", name, p.Name, tp) + } + tp = newNm + } + // it's a pointer if it is optional, or for gopls compatibility + opt, star := propStar(name, p, tp) + json := fmt.Sprintf(" `json:\"%s%s\"`", p.Name, opt) + generateDoc(out, p.Documentation) + fmt.Fprintf(out, "\t%s %s%s %s\n", goName(p.Name), star, tp, json) + } +} + +func genAliases(model Model) { + for _, ta := range model.TypeAliases { + out := new(bytes.Buffer) + generateDoc(out, ta.Documentation) + nm := goName(ta.Name) + if nm != ta.Name { + continue // renamed the type, e.g., "DocumentDiagnosticReport", an or-type to "string" + } + tp := goplsName(ta.Type) + fmt.Fprintf(out, "type %s = %s // (alias) line %d\n", nm, tp, ta.Line) + types[nm] = out.String() + } +} + +func genGenTypes() { + for _, nt := range genTypes { + out := new(bytes.Buffer) + nm := goplsName(nt.typ) + switch nt.kind { + case "literal": + fmt.Fprintf(out, "// created for Literal (%s)\n", nt.name) + fmt.Fprintf(out, "type %s struct { // line %d\n", nm, nt.line+1) + genProps(out, nt.properties, nt.name) // systematic name, not gopls name; is this a good choice? + case "or": + if !strings.HasPrefix(nm, "Or") { + // It was replaced by a narrower type defined elsewhere + continue + } + names := []string{} + for _, t := range nt.items { + if notNil(t) { + names = append(names, goplsName(t)) + } + } + sort.Strings(names) + fmt.Fprintf(out, "// created for Or %v\n", names) + fmt.Fprintf(out, "type %s struct { // line %d\n", nm, nt.line+1) + fmt.Fprintf(out, "\tValue interface{} `json:\"value\"`\n") + case "and": + fmt.Fprintf(out, "// created for And\n") + fmt.Fprintf(out, "type %s struct { // line %d\n", nm, nt.line+1) + for _, x := range nt.items { + nm := goplsName(x) + fmt.Fprintf(out, "\t%s\n", nm) + } + case "tuple": // there's only this one + nt.name = "UIntCommaUInt" + fmt.Fprintf(out, "//created for Tuple\ntype %s struct { // line %d\n", nm, nt.line+1) + fmt.Fprintf(out, "\tFld0 uint32 `json:\"fld0\"`\n") + fmt.Fprintf(out, "\tFld1 uint32 `json:\"fld1\"`\n") + default: + log.Fatalf("%s not handled", nt.kind) + } + out.WriteString("}\n") + types[nm] = out.String() + } +} +func genConsts(model Model) { + for _, e := range model.Enumerations { + out := new(bytes.Buffer) + generateDoc(out, e.Documentation) + tp := goplsName(e.Type) + nm := goName(e.Name) + fmt.Fprintf(out, "type %s %s // line %d\n", nm, tp, e.Line) + types[nm] = out.String() + vals := new(bytes.Buffer) + generateDoc(vals, e.Documentation) + for _, v := range e.Values { + generateDoc(vals, v.Documentation) + nm := goName(v.Name) + more, ok := disambiguate[e.Name] + if ok { + usedDisambiguate[e.Name] = true + nm = more.prefix + nm + more.suffix + nm = goName(nm) // stringType + } + var val string + switch v := v.Value.(type) { + case string: + val = fmt.Sprintf("%q", v) + case float64: + val = fmt.Sprintf("%d", int(v)) + default: + log.Fatalf("impossible type %T", v) + } + fmt.Fprintf(vals, "\t%s %s = %s // line %d\n", nm, e.Name, val, v.Line) + } + consts[nm] = vals.String() + } +} +func genMarshal() { + for _, nt := range genTypes { + nm := goplsName(nt.typ) + if !strings.HasPrefix(nm, "Or") { + continue + } + names := []string{} + for _, t := range nt.items { + if notNil(t) { + names = append(names, goplsName(t)) + } + } + sort.Strings(names) + var buf bytes.Buffer + fmt.Fprintf(&buf, "// from line %d\n", nt.line) + fmt.Fprintf(&buf, "func (t %s) MarshalJSON() ([]byte, error) {\n", nm) + buf.WriteString("\tswitch x := t.Value.(type){\n") + for _, nmx := range names { + fmt.Fprintf(&buf, "\tcase %s:\n", nmx) + fmt.Fprintf(&buf, "\t\treturn json.Marshal(x)\n") + } + buf.WriteString("\tcase nil:\n\t\treturn []byte(\"null\"), nil\n\t}\n") + fmt.Fprintf(&buf, "\treturn nil, fmt.Errorf(\"type %%T not one of %v\", t)\n", names) + buf.WriteString("}\n\n") + + fmt.Fprintf(&buf, "func (t *%s) UnmarshalJSON(x []byte) error {\n", nm) + buf.WriteString("\tif string(x) == \"null\" {\n\t\tt.Value = nil\n\t\t\treturn nil\n\t}\n") + for i, nmx := range names { + fmt.Fprintf(&buf, "\tvar h%d %s\n", i, nmx) + fmt.Fprintf(&buf, "\tif err := json.Unmarshal(x, &h%d); err == nil {\n\t\tt.Value = h%d\n\t\t\treturn nil\n\t\t}\n", i, i) + } + fmt.Fprintf(&buf, "return &UnmarshalError{\"unmarshal failed to match one of %v\"}", names) + buf.WriteString("}\n\n") + jsons[nm] = buf.String() + } +} + +func goplsName(t *Type) string { + nm := typeNames[t] + // translate systematic name to gopls name + if newNm, ok := goplsType[nm]; ok { + usedGoplsType[nm] = true + nm = newNm + } + return nm +} + +func notNil(t *Type) bool { // shutdwon is the special case that needs this + return t != nil && (t.Kind != "base" || t.Name != "null") +} + +func hasNilValue(t string) bool { + // this may be unreliable, and need a supplementary table + if strings.HasPrefix(t, "[]") || strings.HasPrefix(t, "*") { + return true + } + if t == "interface{}" || t == "any" { + return true + } + // that's all the cases that occur currently + return false +} diff --git a/gopls/internal/lsp/protocol/generate/tables.go b/gopls/internal/lsp/protocol/generate/tables.go new file mode 100644 index 000000000..126301a05 --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/tables.go @@ -0,0 +1,327 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +package main + +// prop combines the name of a property with the name of the structure it is in. +type prop [2]string + +const ( + nothing = iota + wantStar + wantOpt + wantOptStar +) + +// goplsStar records the optionality of each field in the protocol. +// The comments are vague hints as to why removing the line is not trivial. +// A.B.C.D means that one of B or C would change to a pointer +// so a test or initialization would be needed +var goplsStar = map[prop]int{ + {"ClientCapabilities", "textDocument"}: wantOpt, // A.B.C.D at fake/editor.go:255 + {"ClientCapabilities", "window"}: wantOpt, // regtest failures + {"ClientCapabilities", "workspace"}: wantOpt, // regtest failures + {"CodeAction", "kind"}: wantOpt, // A.B.C.D + + {"CodeActionClientCapabilities", "codeActionLiteralSupport"}: wantOpt, // regtest failures + + {"CompletionClientCapabilities", "completionItem"}: wantOpt, // A.B.C.D + {"CompletionClientCapabilities", "insertTextMode"}: wantOpt, // A.B.C.D + {"CompletionItem", "kind"}: wantOpt, // need temporary variables + {"CompletionParams", "context"}: wantOpt, // needs nil checks + + {"Diagnostic", "severity"}: wantOpt, // nil checks or more careful thought + {"DidSaveTextDocumentParams", "text"}: wantOptStar, // capabilities_test.go:112 logic + {"DocumentHighlight", "kind"}: wantOpt, // need temporary variables + {"Hover", "range"}: wantOpt, // complex expressions + {"InlayHint", "kind"}: wantOpt, // temporary variables + + {"Lit_CompletionClientCapabilities_completionItem", "tagSupport"}: nothing, // A.B.C. + {"Lit_SemanticTokensClientCapabilities_requests", "full"}: nothing, // A.B.C.D + {"Lit_SemanticTokensClientCapabilities_requests", "range"}: nothing, // A.B.C.D + {"Lit_SemanticTokensClientCapabilities_requests_full_Item1", "delta"}: nothing, // A.B.C.D + {"Lit_SemanticTokensOptions_full_Item1", "delta"}: nothing, // A.B.C. + + {"Lit_TextDocumentContentChangeEvent_Item0", "range"}: wantStar, // == nil test + + {"TextDocumentClientCapabilities", "codeAction"}: wantOpt, // A.B.C.D + {"TextDocumentClientCapabilities", "completion"}: wantOpt, // A.B.C.D + {"TextDocumentClientCapabilities", "documentSymbol"}: wantOpt, // A.B.C.D + {"TextDocumentClientCapabilities", "publishDiagnostics"}: wantOpt, //A.B.C.D + {"TextDocumentClientCapabilities", "semanticTokens"}: wantOpt, // A.B.C.D + {"TextDocumentSyncOptions", "change"}: wantOpt, // &constant + {"WorkDoneProgressParams", "workDoneToken"}: wantOpt, // regtest + {"WorkspaceClientCapabilities", "didChangeConfiguration"}: wantOpt, // A.B.C.D + {"WorkspaceClientCapabilities", "didChangeWatchedFiles"}: wantOpt, // A.B.C.D +} + +// keep track of which entries in goplsStar are used +var usedGoplsStar = make(map[prop]bool) + +// For gopls compatibility, use a different, typically more restrictive, type for some fields. +var renameProp = map[prop]string{ + {"CancelParams", "id"}: "interface{}", + {"Command", "arguments"}: "[]json.RawMessage", + {"CompletionItem", "textEdit"}: "TextEdit", + {"Diagnostic", "code"}: "interface{}", + + {"DocumentDiagnosticReportPartialResult", "relatedDocuments"}: "map[DocumentURI]interface{}", + + {"ExecuteCommandParams", "arguments"}: "[]json.RawMessage", + {"FoldingRange", "kind"}: "string", + {"Hover", "contents"}: "MarkupContent", + {"InlayHint", "label"}: "[]InlayHintLabelPart", + + {"RelatedFullDocumentDiagnosticReport", "relatedDocuments"}: "map[DocumentURI]interface{}", + {"RelatedUnchangedDocumentDiagnosticReport", "relatedDocuments"}: "map[DocumentURI]interface{}", + + // PJW: this one is tricky. + {"ServerCapabilities", "codeActionProvider"}: "interface{}", + + {"ServerCapabilities", "inlayHintProvider"}: "interface{}", + // slightly tricky + {"ServerCapabilities", "renameProvider"}: "interface{}", + // slightly tricky + {"ServerCapabilities", "semanticTokensProvider"}: "interface{}", + // slightly tricky + {"ServerCapabilities", "textDocumentSync"}: "interface{}", + {"TextDocumentEdit", "edits"}: "[]TextEdit", + {"TextDocumentSyncOptions", "save"}: "SaveOptions", + {"WorkspaceEdit", "documentChanges"}: "[]DocumentChanges", +} + +// which entries of renameProp were used +var usedRenameProp = make(map[prop]bool) + +type adjust struct { + prefix, suffix string +} + +// disambiguate specifies prefixes or suffixes to add to all values of +// some enum types to avoid name conflicts +var disambiguate = map[string]adjust{ + "CodeActionTriggerKind": {"CodeAction", ""}, + "CompletionItemKind": {"", "Completion"}, + "CompletionItemTag": {"Compl", ""}, + "DiagnosticSeverity": {"Severity", ""}, + "DocumentDiagnosticReportKind": {"Diagnostic", ""}, + "FileOperationPatternKind": {"", "Pattern"}, + "InsertTextFormat": {"", "TextFormat"}, + "SemanticTokenModifiers": {"Mod", ""}, + "SemanticTokenTypes": {"", "Type"}, + "SignatureHelpTriggerKind": {"Sig", ""}, + "SymbolTag": {"", "Symbol"}, + "WatchKind": {"Watch", ""}, +} + +// which entries of disambiguate got used +var usedDisambiguate = make(map[string]bool) + +// for gopls compatibility, replace generated type names with existing ones +var goplsType = map[string]string{ + "And_RegOpt_textDocument_colorPresentation": "WorkDoneProgressOptionsAndTextDocumentRegistrationOptions", + "ConfigurationParams": "ParamConfiguration", + "DocumentDiagnosticParams": "string", + "DocumentDiagnosticReport": "string", + "DocumentUri": "DocumentURI", + "InitializeParams": "ParamInitialize", + "LSPAny": "interface{}", + + "Lit_CodeActionClientCapabilities_codeActionLiteralSupport": "PCodeActionLiteralSupportPCodeAction", + "Lit_CodeActionClientCapabilities_codeActionLiteralSupport_codeActionKind": "FCodeActionKindPCodeActionLiteralSupport", + + "Lit_CodeActionClientCapabilities_resolveSupport": "PResolveSupportPCodeAction", + "Lit_CodeAction_disabled": "PDisabledMsg_textDocument_codeAction", + "Lit_CompletionClientCapabilities_completionItem": "PCompletionItemPCompletion", + "Lit_CompletionClientCapabilities_completionItemKind": "PCompletionItemKindPCompletion", + + "Lit_CompletionClientCapabilities_completionItem_insertTextModeSupport": "FInsertTextModeSupportPCompletionItem", + + "Lit_CompletionClientCapabilities_completionItem_resolveSupport": "FResolveSupportPCompletionItem", + "Lit_CompletionClientCapabilities_completionItem_tagSupport": "FTagSupportPCompletionItem", + + "Lit_CompletionClientCapabilities_completionList": "PCompletionListPCompletion", + "Lit_CompletionList_itemDefaults": "PItemDefaultsMsg_textDocument_completion", + "Lit_CompletionList_itemDefaults_editRange_Item1": "FEditRangePItemDefaults", + "Lit_CompletionOptions_completionItem": "PCompletionItemPCompletionProvider", + "Lit_DocumentSymbolClientCapabilities_symbolKind": "PSymbolKindPDocumentSymbol", + "Lit_DocumentSymbolClientCapabilities_tagSupport": "PTagSupportPDocumentSymbol", + "Lit_FoldingRangeClientCapabilities_foldingRange": "PFoldingRangePFoldingRange", + "Lit_FoldingRangeClientCapabilities_foldingRangeKind": "PFoldingRangeKindPFoldingRange", + "Lit_GeneralClientCapabilities_staleRequestSupport": "PStaleRequestSupportPGeneral", + "Lit_InitializeResult_serverInfo": "PServerInfoMsg_initialize", + "Lit_InlayHintClientCapabilities_resolveSupport": "PResolveSupportPInlayHint", + "Lit_MarkedString_Item1": "Msg_MarkedString", + "Lit_NotebookDocumentChangeEvent_cells": "PCellsPChange", + "Lit_NotebookDocumentChangeEvent_cells_structure": "FStructurePCells", + "Lit_NotebookDocumentFilter_Item0": "Msg_NotebookDocumentFilter", + + "Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item0": "PNotebookSelectorPNotebookDocumentSync", + + "Lit_PrepareRenameResult_Item1": "Msg_PrepareRename2Gn", + + "Lit_PublishDiagnosticsClientCapabilities_tagSupport": "PTagSupportPPublishDiagnostics", + "Lit_SemanticTokensClientCapabilities_requests": "PRequestsPSemanticTokens", + "Lit_SemanticTokensClientCapabilities_requests_full_Item1": "FFullPRequests", + "Lit_SemanticTokensClientCapabilities_requests_range_Item1": "FRangePRequests", + + "Lit_SemanticTokensOptions_full_Item1": "PFullESemanticTokensOptions", + "Lit_SemanticTokensOptions_range_Item1": "PRangeESemanticTokensOptions", + "Lit_ServerCapabilities_workspace": "Workspace6Gn", + + "Lit_ShowMessageRequestClientCapabilities_messageActionItem": "PMessageActionItemPShowMessage", + "Lit_SignatureHelpClientCapabilities_signatureInformation": "PSignatureInformationPSignatureHelp", + + "Lit_SignatureHelpClientCapabilities_signatureInformation_parameterInformation": "FParameterInformationPSignatureInformation", + + "Lit_TextDocumentContentChangeEvent_Item0": "Msg_TextDocumentContentChangeEvent", + "Lit_TextDocumentFilter_Item0": "Msg_TextDocumentFilter", + "Lit_TextDocumentFilter_Item1": "Msg_TextDocumentFilter", + "Lit_WorkspaceEditClientCapabilities_changeAnnotationSupport": "PChangeAnnotationSupportPWorkspaceEdit", + "Lit_WorkspaceSymbolClientCapabilities_resolveSupport": "PResolveSupportPSymbol", + "Lit_WorkspaceSymbolClientCapabilities_symbolKind": "PSymbolKindPSymbol", + "Lit_WorkspaceSymbolClientCapabilities_tagSupport": "PTagSupportPSymbol", + "Lit_WorkspaceSymbol_location_Item1": "PLocationMsg_workspace_symbol", + "Lit__InitializeParams_clientInfo": "Msg_XInitializeParams_clientInfo", + "Or_CompletionList_itemDefaults_editRange": "OrFEditRangePItemDefaults", + "Or_Declaration": "[]Location", + "Or_DidChangeConfigurationRegistrationOptions_section": "OrPSection_workspace_didChangeConfiguration", + "Or_GlobPattern": "string", + "Or_InlayHintLabelPart_tooltip": "OrPTooltipPLabel", + "Or_InlayHint_tooltip": "OrPTooltip_textDocument_inlayHint", + "Or_LSPAny": "interface{}", + "Or_NotebookDocumentFilter": "Msg_NotebookDocumentFilter", + "Or_NotebookDocumentSyncOptions_notebookSelector_Elem": "PNotebookSelectorPNotebookDocumentSync", + + "Or_NotebookDocumentSyncOptions_notebookSelector_Elem_Item0_notebook": "OrFNotebookPNotebookSelector", + + "Or_ParameterInformation_documentation": "string", + "Or_ParameterInformation_label": "string", + "Or_PrepareRenameResult": "Msg_PrepareRename2Gn", + "Or_ProgressToken": "interface{}", + "Or_Result_textDocument_completion": "CompletionList", + "Or_Result_textDocument_declaration": "Or_textDocument_declaration", + "Or_Result_textDocument_definition": "[]Location", + "Or_Result_textDocument_documentSymbol": "[]interface{}", + "Or_Result_textDocument_implementation": "[]Location", + "Or_Result_textDocument_semanticTokens_full_delta": "interface{}", + "Or_Result_textDocument_typeDefinition": "[]Location", + "Or_Result_workspace_symbol": "[]SymbolInformation", + "Or_TextDocumentContentChangeEvent": "Msg_TextDocumentContentChangeEvent", + "Or_TextDocumentFilter": "Msg_TextDocumentFilter", + "Or_WorkspaceFoldersServerCapabilities_changeNotifications": "string", + "Or_WorkspaceSymbol_location": "OrPLocation_workspace_symbol", + "PrepareRenameResult": "PrepareRename2Gn", + "Tuple_ParameterInformation_label_Item1": "UIntCommaUInt", + "WorkspaceFoldersServerCapabilities": "WorkspaceFolders5Gn", + "[]LSPAny": "[]interface{}", + "[]Or_NotebookDocumentSyncOptions_notebookSelector_Elem": "[]PNotebookSelectorPNotebookDocumentSync", + "[]Or_Result_textDocument_codeAction_Item0_Elem": "[]CodeAction", + "[]PreviousResultId": "[]PreviousResultID", + "[]uinteger": "[]uint32", + "boolean": "bool", + "decimal": "float64", + "integer": "int32", + "map[DocumentUri][]TextEdit": "map[DocumentURI][]TextEdit", + "uinteger": "uint32", +} + +var usedGoplsType = make(map[string]bool) + +// methodNames is a map from the method to the name of the function that handles it +var methodNames = map[string]string{ + "$/cancelRequest": "CancelRequest", + "$/logTrace": "LogTrace", + "$/progress": "Progress", + "$/setTrace": "SetTrace", + "callHierarchy/incomingCalls": "IncomingCalls", + "callHierarchy/outgoingCalls": "OutgoingCalls", + "client/registerCapability": "RegisterCapability", + "client/unregisterCapability": "UnregisterCapability", + "codeAction/resolve": "ResolveCodeAction", + "codeLens/resolve": "ResolveCodeLens", + "completionItem/resolve": "ResolveCompletionItem", + "documentLink/resolve": "ResolveDocumentLink", + "exit": "Exit", + "initialize": "Initialize", + "initialized": "Initialized", + "inlayHint/resolve": "Resolve", + "notebookDocument/didChange": "DidChangeNotebookDocument", + "notebookDocument/didClose": "DidCloseNotebookDocument", + "notebookDocument/didOpen": "DidOpenNotebookDocument", + "notebookDocument/didSave": "DidSaveNotebookDocument", + "shutdown": "Shutdown", + "telemetry/event": "Event", + "textDocument/codeAction": "CodeAction", + "textDocument/codeLens": "CodeLens", + "textDocument/colorPresentation": "ColorPresentation", + "textDocument/completion": "Completion", + "textDocument/declaration": "Declaration", + "textDocument/definition": "Definition", + "textDocument/diagnostic": "Diagnostic", + "textDocument/didChange": "DidChange", + "textDocument/didClose": "DidClose", + "textDocument/didOpen": "DidOpen", + "textDocument/didSave": "DidSave", + "textDocument/documentColor": "DocumentColor", + "textDocument/documentHighlight": "DocumentHighlight", + "textDocument/documentLink": "DocumentLink", + "textDocument/documentSymbol": "DocumentSymbol", + "textDocument/foldingRange": "FoldingRange", + "textDocument/formatting": "Formatting", + "textDocument/hover": "Hover", + "textDocument/implementation": "Implementation", + "textDocument/inlayHint": "InlayHint", + "textDocument/inlineValue": "InlineValue", + "textDocument/linkedEditingRange": "LinkedEditingRange", + "textDocument/moniker": "Moniker", + "textDocument/onTypeFormatting": "OnTypeFormatting", + "textDocument/prepareCallHierarchy": "PrepareCallHierarchy", + "textDocument/prepareRename": "PrepareRename", + "textDocument/prepareTypeHierarchy": "PrepareTypeHierarchy", + "textDocument/publishDiagnostics": "PublishDiagnostics", + "textDocument/rangeFormatting": "RangeFormatting", + "textDocument/references": "References", + "textDocument/rename": "Rename", + "textDocument/selectionRange": "SelectionRange", + "textDocument/semanticTokens/full": "SemanticTokensFull", + "textDocument/semanticTokens/full/delta": "SemanticTokensFullDelta", + "textDocument/semanticTokens/range": "SemanticTokensRange", + "textDocument/signatureHelp": "SignatureHelp", + "textDocument/typeDefinition": "TypeDefinition", + "textDocument/willSave": "WillSave", + "textDocument/willSaveWaitUntil": "WillSaveWaitUntil", + "typeHierarchy/subtypes": "Subtypes", + "typeHierarchy/supertypes": "Supertypes", + "window/logMessage": "LogMessage", + "window/showDocument": "ShowDocument", + "window/showMessage": "ShowMessage", + "window/showMessageRequest": "ShowMessageRequest", + "window/workDoneProgress/cancel": "WorkDoneProgressCancel", + "window/workDoneProgress/create": "WorkDoneProgressCreate", + "workspace/applyEdit": "ApplyEdit", + "workspace/codeLens/refresh": "CodeLensRefresh", + "workspace/configuration": "Configuration", + "workspace/diagnostic": "DiagnosticWorkspace", + "workspace/diagnostic/refresh": "DiagnosticRefresh", + "workspace/didChangeConfiguration": "DidChangeConfiguration", + "workspace/didChangeWatchedFiles": "DidChangeWatchedFiles", + "workspace/didChangeWorkspaceFolders": "DidChangeWorkspaceFolders", + "workspace/didCreateFiles": "DidCreateFiles", + "workspace/didDeleteFiles": "DidDeleteFiles", + "workspace/didRenameFiles": "DidRenameFiles", + "workspace/executeCommand": "ExecuteCommand", + "workspace/inlayHint/refresh": "InlayHintRefresh", + "workspace/inlineValue/refresh": "InlineValueRefresh", + "workspace/semanticTokens/refresh": "SemanticTokensRefresh", + "workspace/symbol": "Symbol", + "workspace/willCreateFiles": "WillCreateFiles", + "workspace/willDeleteFiles": "WillDeleteFiles", + "workspace/willRenameFiles": "WillRenameFiles", + "workspace/workspaceFolders": "WorkspaceFolders", + "workspaceSymbol/resolve": "ResolveWorkspaceSymbol", +} diff --git a/gopls/internal/lsp/protocol/generate/typenames.go b/gopls/internal/lsp/protocol/generate/typenames.go new file mode 100644 index 000000000..8bacdd2a1 --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/typenames.go @@ -0,0 +1,184 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +package main + +import ( + "fmt" + "log" + "strings" +) + +var typeNames = make(map[*Type]string) +var genTypes []*newType + +func findTypeNames(model Model) { + for _, s := range model.Structures { + for _, e := range s.Extends { + nameType(e, nil) // all references + } + for _, m := range s.Mixins { + nameType(m, nil) // all references + } + for _, p := range s.Properties { + nameType(p.Type, []string{s.Name, p.Name}) + } + } + for _, t := range model.Enumerations { + nameType(t.Type, []string{t.Name}) + } + for _, t := range model.TypeAliases { + nameType(t.Type, []string{t.Name}) + } + for _, r := range model.Requests { + nameType(r.Params, []string{"Param", r.Method}) + nameType(r.Result, []string{"Result", r.Method}) + nameType(r.RegistrationOptions, []string{"RegOpt", r.Method}) + } + for _, n := range model.Notifications { + nameType(n.Params, []string{"Param", n.Method}) + nameType(n.RegistrationOptions, []string{"RegOpt", n.Method}) + } +} + +// nameType populates typeNames[t] with the computed name of the type. +// path is the list of enclosing constructs in the JSON model. +func nameType(t *Type, path []string) string { + if t == nil || typeNames[t] != "" { + return "" + } + switch t.Kind { + case "base": + typeNames[t] = t.Name + return t.Name + case "reference": + typeNames[t] = t.Name + return t.Name + case "array": + nm := "[]" + nameType(t.Element, append(path, "Elem")) + typeNames[t] = nm + return nm + case "map": + key := nameType(t.Key, nil) // never a generated type + value := nameType(t.Value.(*Type), append(path, "Value")) + nm := "map[" + key + "]" + value + typeNames[t] = nm + return nm + // generated types + case "and": + nm := nameFromPath("And", path) + typeNames[t] = nm + for _, it := range t.Items { + nameType(it, append(path, "Item")) + } + genTypes = append(genTypes, &newType{ + name: nm, + typ: t, + kind: "and", + items: t.Items, + line: t.Line, + }) + return nm + case "literal": + nm := nameFromPath("Lit", path) + typeNames[t] = nm + for _, p := range t.Value.(ParseLiteral).Properties { + nameType(p.Type, append(path, p.Name)) + } + genTypes = append(genTypes, &newType{ + name: nm, + typ: t, + kind: "literal", + properties: t.Value.(ParseLiteral).Properties, + line: t.Line, + }) + return nm + case "tuple": + nm := nameFromPath("Tuple", path) + typeNames[t] = nm + for _, it := range t.Items { + nameType(it, append(path, "Item")) + } + genTypes = append(genTypes, &newType{ + name: nm, + typ: t, + kind: "tuple", + items: t.Items, + line: t.Line, + }) + return nm + case "or": + nm := nameFromPath("Or", path) + typeNames[t] = nm + for i, it := range t.Items { + // these names depend on the ordering within the "or" type + nameType(it, append(path, fmt.Sprintf("Item%d", i))) + } + // this code handles an "or" of stringLiterals (_InitializeParams.trace) + names := make(map[string]int) + msg := "" + for _, it := range t.Items { + if line, ok := names[typeNames[it]]; ok { + // duplicate component names are bad + msg += fmt.Sprintf("lines %d %d dup, %s for %s\n", line, it.Line, typeNames[it], nm) + } + names[typeNames[it]] = t.Line + } + // this code handles an "or" of stringLiterals (_InitializeParams.trace) + if len(names) == 1 { + var solekey string + for k := range names { + solekey = k // the sole name + } + if solekey == "string" { // _InitializeParams.trace + typeNames[t] = "string" + return "string" + } + // otherwise unexpected + log.Printf("unexpected: single-case 'or' type has non-string key %s: %s", nm, solekey) + log.Fatal(msg) + } else if len(names) == 2 { + // if one of the names is null, just use the other, rather than generating an "or". + // This removes about 40 types from the generated code. An entry in goplsStar + // could be added to handle the null case, if necessary. + newNm := "" + sawNull := false + for k := range names { + if k == "null" { + sawNull = true + } else { + newNm = k + } + } + if sawNull { + typeNames[t] = newNm + return newNm + } + } + genTypes = append(genTypes, &newType{ + name: nm, + typ: t, + kind: "or", + items: t.Items, + line: t.Line, + }) + return nm + case "stringLiteral": // a single type, like 'kind' or 'rename' + typeNames[t] = "string" + return "string" + default: + log.Fatalf("nameType: %T unexpected, line:%d path:%v", t, t.Line, path) + panic("unreachable in nameType") + } +} + +func nameFromPath(prefix string, path []string) string { + nm := prefix + "_" + strings.Join(path, "_") + // methods have slashes + nm = strings.ReplaceAll(nm, "/", "_") + return nm +} diff --git a/gopls/internal/lsp/protocol/generate/types.go b/gopls/internal/lsp/protocol/generate/types.go new file mode 100644 index 000000000..0d01ae43c --- /dev/null +++ b/gopls/internal/lsp/protocol/generate/types.go @@ -0,0 +1,170 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.19 +// +build go1.19 + +package main + +import ( + "fmt" + "sort" +) + +// Model contains the parsed version of the spec +type Model struct { + Version Metadata `json:"metaData"` + Requests []*Request `json:"requests"` + Notifications []*Notification `json:"notifications"` + Structures []*Structure `json:"structures"` + Enumerations []*Enumeration `json:"enumerations"` + TypeAliases []*TypeAlias `json:"typeAliases"` + Line int `json:"line"` +} + +// Metadata is information about the version of the spec +type Metadata struct { + Version string `json:"version"` + Line int `json:"line"` +} + +// A Request is the parsed version of an LSP request +type Request struct { + Documentation string `json:"documentation"` + ErrorData *Type `json:"errorData"` + Direction string `json:"messageDirection"` + Method string `json:"method"` + Params *Type `json:"params"` + PartialResult *Type `json:"partialResult"` + Proposed bool `json:"proposed"` + RegistrationMethod string `json:"registrationMethod"` + RegistrationOptions *Type `json:"registrationOptions"` + Result *Type `json:"result"` + Since string `json:"since"` + Line int `json:"line"` +} + +// A Notificatin is the parsed version of an LSP notification +type Notification struct { + Documentation string `json:"documentation"` + Direction string `json:"messageDirection"` + Method string `json:"method"` + Params *Type `json:"params"` + Proposed bool `json:"proposed"` + RegistrationMethod string `json:"registrationMethod"` + RegistrationOptions *Type `json:"registrationOptions"` + Since string `json:"since"` + Line int `json:"line"` +} + +// A Structure is the parsed version of an LSP structure from the spec +type Structure struct { + Documentation string `json:"documentation"` + Extends []*Type `json:"extends"` + Mixins []*Type `json:"mixins"` + Name string `json:"name"` + Properties []NameType `json:"properties"` + Proposed bool `json:"proposed"` + Since string `json:"since"` + Line int `json:"line"` +} + +// An enumeration is the parsed version of an LSP enumeration from the spec +type Enumeration struct { + Documentation string `json:"documentation"` + Name string `json:"name"` + Proposed bool `json:"proposed"` + Since string `json:"since"` + SupportsCustomValues bool `json:"supportsCustomValues"` + Type *Type `json:"type"` + Values []NameValue `json:"values"` + Line int `json:"line"` +} + +// A TypeAlias is the parsed version of an LSP type alias from the spec +type TypeAlias struct { + Documentation string `json:"documentation"` + Deprecated string `json:"deprecated"` + Name string `json:"name"` + Proposed bool `json:"proposed"` + Since string `json:"since"` + Type *Type `json:"type"` + Line int `json:"line"` +} + +// A NameValue describes an enumeration constant +type NameValue struct { + Documentation string `json:"documentation"` + Name string `json:"name"` + Proposed bool `json:"proposed"` + Since string `json:"since"` + Value any `json:"value"` // number or string + Line int `json:"line"` +} + +// A Type is the parsed version of an LSP type from the spec, +// or a Type the code constructs +type Type struct { + Kind string `json:"kind"` // -- which kind goes with which field -- + Items []*Type `json:"items"` // "and", "or", "tuple" + Element *Type `json:"element"` // "array" + Name string `json:"name"` // "base", "reference" + Key *Type `json:"key"` // "map" + Value any `json:"value"` // "map", "stringLiteral", "literal" + Line int `json:"line"` // JSON source line +} + +// ParsedLiteral is Type.Value when Type.Kind is "literal" +type ParseLiteral struct { + Properties `json:"properties"` +} + +// A NameType represents the name and type of a structure element +type NameType struct { + Name string `json:"name"` + Type *Type `json:"type"` + Optional bool `json:"optional"` + Documentation string `json:"documentation"` + Deprecated string `json:"deprecated"` + Since string `json:"since"` + Proposed bool `json:"proposed"` + Line int `json:"line"` +} + +// Properties are the collection of structure fields +type Properties []NameType + +// addLineNumbers adds a "line" field to each object in the JSON. +func addLineNumbers(buf []byte) []byte { + var ans []byte + // In the specification .json file, the delimiter '{' is + // always followed by a newline. There are other {s embedded in strings. + // json.Token does not return \n, or :, or , so using it would + // require parsing the json to reconstruct the missing information. + for linecnt, i := 1, 0; i < len(buf); i++ { + ans = append(ans, buf[i]) + switch buf[i] { + case '{': + if buf[i+1] == '\n' { + ans = append(ans, fmt.Sprintf(`"line": %d, `, linecnt)...) + // warning: this would fail if the spec file had + // `"value": {\n}`, but it does not, as comma is a separator. + } + case '\n': + linecnt++ + } + } + return ans +} + +type sortedMap[T any] map[string]T + +func (s sortedMap[T]) keys() []string { + var keys []string + for k := range s { + keys = append(keys, k) + } + sort.Strings(keys) + return keys +} diff --git a/gopls/internal/lsp/protocol/log.go b/gopls/internal/lsp/protocol/log.go new file mode 100644 index 000000000..fdcbb7a8d --- /dev/null +++ b/gopls/internal/lsp/protocol/log.go @@ -0,0 +1,136 @@ +// Copyright 2019 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +import ( + "context" + "fmt" + "io" + "strings" + "sync" + "time" + + "golang.org/x/tools/internal/jsonrpc2" +) + +type loggingStream struct { + stream jsonrpc2.Stream + logMu sync.Mutex + log io.Writer +} + +// LoggingStream returns a stream that does LSP protocol logging too +func LoggingStream(str jsonrpc2.Stream, w io.Writer) jsonrpc2.Stream { + return &loggingStream{stream: str, log: w} +} + +func (s *loggingStream) Read(ctx context.Context) (jsonrpc2.Message, int64, error) { + msg, count, err := s.stream.Read(ctx) + if err == nil { + s.logCommon(msg, true) + } + return msg, count, err +} + +func (s *loggingStream) Write(ctx context.Context, msg jsonrpc2.Message) (int64, error) { + s.logCommon(msg, false) + count, err := s.stream.Write(ctx, msg) + return count, err +} + +func (s *loggingStream) Close() error { + return s.stream.Close() +} + +type req struct { + method string + start time.Time +} + +type mapped struct { + mu sync.Mutex + clientCalls map[string]req + serverCalls map[string]req +} + +var maps = &mapped{ + sync.Mutex{}, + make(map[string]req), + make(map[string]req), +} + +// these 4 methods are each used exactly once, but it seemed +// better to have the encapsulation rather than ad hoc mutex +// code in 4 places +func (m *mapped) client(id string) req { + m.mu.Lock() + defer m.mu.Unlock() + v := m.clientCalls[id] + delete(m.clientCalls, id) + return v +} + +func (m *mapped) server(id string) req { + m.mu.Lock() + defer m.mu.Unlock() + v := m.serverCalls[id] + delete(m.serverCalls, id) + return v +} + +func (m *mapped) setClient(id string, r req) { + m.mu.Lock() + defer m.mu.Unlock() + m.clientCalls[id] = r +} + +func (m *mapped) setServer(id string, r req) { + m.mu.Lock() + defer m.mu.Unlock() + m.serverCalls[id] = r +} + +const eor = "\r\n\r\n\r\n" + +func (s *loggingStream) logCommon(msg jsonrpc2.Message, isRead bool) { + s.logMu.Lock() + defer s.logMu.Unlock() + direction, pastTense := "Received", "Received" + get, set := maps.client, maps.setServer + if isRead { + direction, pastTense = "Sending", "Sent" + get, set = maps.server, maps.setClient + } + if msg == nil || s.log == nil { + return + } + tm := time.Now() + tmfmt := tm.Format("15:04:05.000 PM") + + buf := strings.Builder{} + fmt.Fprintf(&buf, "[Trace - %s] ", tmfmt) // common beginning + switch msg := msg.(type) { + case *jsonrpc2.Call: + id := fmt.Sprint(msg.ID()) + fmt.Fprintf(&buf, "%s request '%s - (%s)'.\n", direction, msg.Method(), id) + fmt.Fprintf(&buf, "Params: %s%s", msg.Params(), eor) + set(id, req{method: msg.Method(), start: tm}) + case *jsonrpc2.Notification: + fmt.Fprintf(&buf, "%s notification '%s'.\n", direction, msg.Method()) + fmt.Fprintf(&buf, "Params: %s%s", msg.Params(), eor) + case *jsonrpc2.Response: + id := fmt.Sprint(msg.ID()) + if err := msg.Err(); err != nil { + fmt.Fprintf(s.log, "[Error - %s] %s #%s %s%s", pastTense, tmfmt, id, err, eor) + return + } + cc := get(id) + elapsed := tm.Sub(cc.start) + fmt.Fprintf(&buf, "%s response '%s - (%s)' in %dms.\n", + direction, cc.method, id, elapsed/time.Millisecond) + fmt.Fprintf(&buf, "Result: %s%s", msg.Result(), eor) + } + s.log.Write([]byte(buf.String())) +} diff --git a/gopls/internal/lsp/protocol/mapper.go b/gopls/internal/lsp/protocol/mapper.go new file mode 100644 index 000000000..d61524d83 --- /dev/null +++ b/gopls/internal/lsp/protocol/mapper.go @@ -0,0 +1,529 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +// This file defines Mapper, which wraps a file content buffer +// ([]byte) and provides efficient conversion between every kind of +// position representation. +// +// gopls uses four main representations of position: +// +// 1. byte offsets, e.g. (start, end int), starting from zero. +// +// 2. go/token notation. Use these types when interacting directly +// with the go/* syntax packages: +// +// token.Pos +// token.FileSet +// token.File +// +// Because File.Offset and File.Pos panic on invalid inputs, +// we do not call them directly and instead use the safetoken package +// for these conversions. This is enforced by a static check. +// +// Beware also that the methods of token.File have two bugs for which +// safetoken contains workarounds: +// - #57490, whereby the parser may create ast.Nodes during error +// recovery whose computed positions are out of bounds (EOF+1). +// - #41029, whereby the wrong line number is returned for the EOF position. +// +// 3. the span package. +// +// span.Point = (line, col8, offset). +// span.Span = (uri URI, start, end span.Point) +// +// Line and column are 1-based. +// Columns are measured in bytes (UTF-8 codes). +// All fields are optional. +// +// These types are useful as intermediate conversions of validated +// ranges (though MappedRange is superior as it is self contained +// and universally convertible). Since their fields are optional +// they are also useful for parsing user-provided positions (e.g. in +// the CLI) before we have access to file contents. +// +// 4. protocol, the LSP RPC message format. +// +// protocol.Position = (Line, Character uint32) +// protocol.Range = (start, end Position) +// protocol.Location = (URI, protocol.Range) +// +// Line and Character are 0-based. +// Characters (columns) are measured in UTF-16 codes. +// +// protocol.Mapper holds the (URI, Content) of a file, enabling +// efficient mapping between byte offsets, span ranges, and +// protocol ranges. +// +// protocol.MappedRange holds a protocol.Mapper and valid (start, +// end int) byte offsets, enabling infallible, efficient conversion +// to any other format. + +import ( + "bytes" + "fmt" + "go/ast" + "go/token" + "path/filepath" + "sort" + "strings" + "sync" + "unicode/utf8" + + "golang.org/x/tools/gopls/internal/lsp/safetoken" + "golang.org/x/tools/gopls/internal/span" + "golang.org/x/tools/internal/bug" +) + +// A Mapper wraps the content of a file and provides mapping +// between byte offsets and notations of position such as: +// +// - (line, col8) pairs, where col8 is a 1-based UTF-8 column number +// (bytes), as used by the go/token and span packages. +// +// - (line, col16) pairs, where col16 is a 1-based UTF-16 column +// number, as used by the LSP protocol. +// +// All conversion methods are named "FromTo", where From and To are the two types. +// For example, the PointPosition method converts from a Point to a Position. +// +// Mapper does not intrinsically depend on go/token-based +// representations. Use safetoken to map between token.Pos <=> byte +// offsets, or the convenience methods such as PosPosition, +// NodePosition, or NodeRange. +// +// See overview comments at top of this file. +type Mapper struct { + URI span.URI + Content []byte + + // Line-number information is requested only for a tiny + // fraction of Mappers, so we compute it lazily. + // Call initLines() before accessing fields below. + linesOnce sync.Once + lineStart []int // byte offset of start of ith line (0-based); last=EOF iff \n-terminated + nonASCII bool + + // TODO(adonovan): adding an extra lineStart entry for EOF + // might simplify every method that accesses it. Try it out. +} + +// NewMapper creates a new mapper for the given URI and content. +func NewMapper(uri span.URI, content []byte) *Mapper { + return &Mapper{URI: uri, Content: content} +} + +// initLines populates the lineStart table. +func (m *Mapper) initLines() { + m.linesOnce.Do(func() { + nlines := bytes.Count(m.Content, []byte("\n")) + m.lineStart = make([]int, 1, nlines+1) // initially []int{0} + for offset, b := range m.Content { + if b == '\n' { + m.lineStart = append(m.lineStart, offset+1) + } + if b >= utf8.RuneSelf { + m.nonASCII = true + } + } + }) +} + +// -- conversions from span (UTF-8) domain -- + +// SpanLocation converts a (UTF-8) span to a protocol (UTF-16) range. +// Precondition: the URIs of SpanLocation and Mapper match. +func (m *Mapper) SpanLocation(s span.Span) (Location, error) { + rng, err := m.SpanRange(s) + if err != nil { + return Location{}, err + } + return m.RangeLocation(rng), nil +} + +// SpanRange converts a (UTF-8) span to a protocol (UTF-16) range. +// Precondition: the URIs of Span and Mapper match. +func (m *Mapper) SpanRange(s span.Span) (Range, error) { + // Assert that we aren't using the wrong mapper. + // We check only the base name, and case insensitively, + // because we can't assume clean paths, no symbolic links, + // case-sensitive directories. The authoritative answer + // requires querying the file system, and we don't want + // to do that. + if !strings.EqualFold(filepath.Base(string(m.URI)), filepath.Base(string(s.URI()))) { + return Range{}, bug.Errorf("mapper is for file %q instead of %q", m.URI, s.URI()) + } + start, err := m.PointPosition(s.Start()) + if err != nil { + return Range{}, fmt.Errorf("start: %w", err) + } + end, err := m.PointPosition(s.End()) + if err != nil { + return Range{}, fmt.Errorf("end: %w", err) + } + return Range{Start: start, End: end}, nil +} + +// PointPosition converts a valid span (UTF-8) point to a protocol (UTF-16) position. +func (m *Mapper) PointPosition(p span.Point) (Position, error) { + if p.HasPosition() { + line, col8 := p.Line()-1, p.Column()-1 // both 0-based + m.initLines() + if line >= len(m.lineStart) { + return Position{}, fmt.Errorf("line number %d out of range (max %d)", line, len(m.lineStart)) + } + offset := m.lineStart[line] + end := offset + col8 + + // Validate column. + if end > len(m.Content) { + return Position{}, fmt.Errorf("column is beyond end of file") + } else if line+1 < len(m.lineStart) && end >= m.lineStart[line+1] { + return Position{}, fmt.Errorf("column is beyond end of line") + } + + char := UTF16Len(m.Content[offset:end]) + return Position{Line: uint32(line), Character: uint32(char)}, nil + } + if p.HasOffset() { + return m.OffsetPosition(p.Offset()) + } + return Position{}, fmt.Errorf("point has neither offset nor line/column") +} + +// -- conversions from byte offsets -- + +// OffsetLocation converts a byte-offset interval to a protocol (UTF-16) location. +func (m *Mapper) OffsetLocation(start, end int) (Location, error) { + rng, err := m.OffsetRange(start, end) + if err != nil { + return Location{}, err + } + return m.RangeLocation(rng), nil +} + +// OffsetRange converts a byte-offset interval to a protocol (UTF-16) range. +func (m *Mapper) OffsetRange(start, end int) (Range, error) { + if start > end { + return Range{}, fmt.Errorf("start offset (%d) > end (%d)", start, end) + } + startPosition, err := m.OffsetPosition(start) + if err != nil { + return Range{}, fmt.Errorf("start: %v", err) + } + endPosition, err := m.OffsetPosition(end) + if err != nil { + return Range{}, fmt.Errorf("end: %v", err) + } + return Range{Start: startPosition, End: endPosition}, nil +} + +// OffsetSpan converts a byte-offset interval to a (UTF-8) span. +// The resulting span contains line, column, and offset information. +func (m *Mapper) OffsetSpan(start, end int) (span.Span, error) { + if start > end { + return span.Span{}, fmt.Errorf("start offset (%d) > end (%d)", start, end) + } + startPoint, err := m.OffsetPoint(start) + if err != nil { + return span.Span{}, fmt.Errorf("start: %v", err) + } + endPoint, err := m.OffsetPoint(end) + if err != nil { + return span.Span{}, fmt.Errorf("end: %v", err) + } + return span.New(m.URI, startPoint, endPoint), nil +} + +// OffsetPosition converts a byte offset to a protocol (UTF-16) position. +func (m *Mapper) OffsetPosition(offset int) (Position, error) { + if !(0 <= offset && offset <= len(m.Content)) { + return Position{}, fmt.Errorf("invalid offset %d (want 0-%d)", offset, len(m.Content)) + } + // No error may be returned after this point, + // even if the offset does not fall at a rune boundary. + // (See panic in MappedRange.Range reachable.) + + line, col16 := m.lineCol16(offset) + return Position{Line: uint32(line), Character: uint32(col16)}, nil +} + +// lineCol16 converts a valid byte offset to line and UTF-16 column numbers, both 0-based. +func (m *Mapper) lineCol16(offset int) (int, int) { + line, start, cr := m.line(offset) + var col16 int + if m.nonASCII { + col16 = UTF16Len(m.Content[start:offset]) + } else { + col16 = offset - start + } + if cr { + col16-- // retreat from \r at line end + } + return line, col16 +} + +// lineCol8 converts a valid byte offset to line and UTF-8 column numbers, both 0-based. +func (m *Mapper) lineCol8(offset int) (int, int) { + line, start, cr := m.line(offset) + col8 := offset - start + if cr { + col8-- // retreat from \r at line end + } + return line, col8 +} + +// line returns: +// - the 0-based index of the line that encloses the (valid) byte offset; +// - the start offset of that line; and +// - whether the offset denotes a carriage return (\r) at line end. +func (m *Mapper) line(offset int) (int, int, bool) { + m.initLines() + // In effect, binary search returns a 1-based result. + line := sort.Search(len(m.lineStart), func(i int) bool { + return offset < m.lineStart[i] + }) + + // Adjustment for line-endings: \r|\n is the same as |\r\n. + var eol int + if line == len(m.lineStart) { + eol = len(m.Content) // EOF + } else { + eol = m.lineStart[line] - 1 + } + cr := offset == eol && offset > 0 && m.Content[offset-1] == '\r' + + line-- // 0-based + + return line, m.lineStart[line], cr +} + +// OffsetPoint converts a byte offset to a span (UTF-8) point. +// The resulting point contains line, column, and offset information. +func (m *Mapper) OffsetPoint(offset int) (span.Point, error) { + if !(0 <= offset && offset <= len(m.Content)) { + return span.Point{}, fmt.Errorf("invalid offset %d (want 0-%d)", offset, len(m.Content)) + } + line, col8 := m.lineCol8(offset) + return span.NewPoint(line+1, col8+1, offset), nil +} + +// OffsetMappedRange returns a MappedRange for the given byte offsets. +// A MappedRange can be converted to any other form. +func (m *Mapper) OffsetMappedRange(start, end int) (MappedRange, error) { + if !(0 <= start && start <= end && end <= len(m.Content)) { + return MappedRange{}, fmt.Errorf("invalid offsets (%d, %d) (file %s has size %d)", start, end, m.URI, len(m.Content)) + } + return MappedRange{m, start, end}, nil +} + +// -- conversions from protocol (UTF-16) domain -- + +// LocationSpan converts a protocol (UTF-16) Location to a (UTF-8) span. +// Precondition: the URIs of Location and Mapper match. +func (m *Mapper) LocationSpan(l Location) (span.Span, error) { + // TODO(adonovan): check that l.URI matches m.URI. + return m.RangeSpan(l.Range) +} + +// RangeSpan converts a protocol (UTF-16) range to a (UTF-8) span. +// The resulting span has valid Positions and Offsets. +func (m *Mapper) RangeSpan(r Range) (span.Span, error) { + start, end, err := m.RangeOffsets(r) + if err != nil { + return span.Span{}, err + } + return m.OffsetSpan(start, end) +} + +// RangeOffsets converts a protocol (UTF-16) range to start/end byte offsets. +func (m *Mapper) RangeOffsets(r Range) (int, int, error) { + start, err := m.PositionOffset(r.Start) + if err != nil { + return 0, 0, err + } + end, err := m.PositionOffset(r.End) + if err != nil { + return 0, 0, err + } + return start, end, nil +} + +// PositionOffset converts a protocol (UTF-16) position to a byte offset. +func (m *Mapper) PositionOffset(p Position) (int, error) { + m.initLines() + + // Validate line number. + if p.Line > uint32(len(m.lineStart)) { + return 0, fmt.Errorf("line number %d out of range 0-%d", p.Line, len(m.lineStart)) + } else if p.Line == uint32(len(m.lineStart)) { + if p.Character == 0 { + return len(m.Content), nil // EOF + } + return 0, fmt.Errorf("column is beyond end of file") + } + + offset := m.lineStart[p.Line] + content := m.Content[offset:] // rest of file from start of enclosing line + + // Advance bytes up to the required number of UTF-16 codes. + col8 := 0 + for col16 := 0; col16 < int(p.Character); col16++ { + r, sz := utf8.DecodeRune(content) + if sz == 0 { + return 0, fmt.Errorf("column is beyond end of file") + } + if r == '\n' { + return 0, fmt.Errorf("column is beyond end of line") + } + if sz == 1 && r == utf8.RuneError { + return 0, fmt.Errorf("buffer contains invalid UTF-8 text") + } + content = content[sz:] + + if r >= 0x10000 { + col16++ // rune was encoded by a pair of surrogate UTF-16 codes + + if col16 == int(p.Character) { + break // requested position is in the middle of a rune + } + } + col8 += sz + } + return offset + col8, nil +} + +// PositionPoint converts a protocol (UTF-16) position to a span (UTF-8) point. +// The resulting point has a valid Position and Offset. +func (m *Mapper) PositionPoint(p Position) (span.Point, error) { + offset, err := m.PositionOffset(p) + if err != nil { + return span.Point{}, err + } + line, col8 := m.lineCol8(offset) + + return span.NewPoint(line+1, col8+1, offset), nil +} + +// -- go/token domain convenience methods -- + +// PosPosition converts a token pos to a protocol (UTF-16) position. +func (m *Mapper) PosPosition(tf *token.File, pos token.Pos) (Position, error) { + offset, err := safetoken.Offset(tf, pos) + if err != nil { + return Position{}, err + } + return m.OffsetPosition(offset) +} + +// PosLocation converts a token range to a protocol (UTF-16) location. +func (m *Mapper) PosLocation(tf *token.File, start, end token.Pos) (Location, error) { + startOffset, endOffset, err := safetoken.Offsets(tf, start, end) + if err != nil { + return Location{}, err + } + rng, err := m.OffsetRange(startOffset, endOffset) + if err != nil { + return Location{}, err + } + return m.RangeLocation(rng), nil +} + +// PosRange converts a token range to a protocol (UTF-16) range. +func (m *Mapper) PosRange(tf *token.File, start, end token.Pos) (Range, error) { + startOffset, endOffset, err := safetoken.Offsets(tf, start, end) + if err != nil { + return Range{}, err + } + return m.OffsetRange(startOffset, endOffset) +} + +// NodeRange converts a syntax node range to a protocol (UTF-16) range. +func (m *Mapper) NodeRange(tf *token.File, node ast.Node) (Range, error) { + return m.PosRange(tf, node.Pos(), node.End()) +} + +// RangeLocation pairs a protocol Range with its URI, in a Location. +func (m *Mapper) RangeLocation(rng Range) Location { + return Location{URI: URIFromSpanURI(m.URI), Range: rng} +} + +// PosMappedRange returns a MappedRange for the given token.Pos range. +func (m *Mapper) PosMappedRange(tf *token.File, start, end token.Pos) (MappedRange, error) { + startOffset, endOffset, err := safetoken.Offsets(tf, start, end) + if err != nil { + return MappedRange{}, nil + } + return m.OffsetMappedRange(startOffset, endOffset) +} + +// NodeMappedRange returns a MappedRange for the given node range. +func (m *Mapper) NodeMappedRange(tf *token.File, node ast.Node) (MappedRange, error) { + return m.PosMappedRange(tf, node.Pos(), node.End()) +} + +// -- MappedRange -- + +// A MappedRange represents a valid byte-offset range of a file. +// Through its Mapper it can be converted into other forms such +// as protocol.Range or span.Span. +// +// Construct one by calling Mapper.OffsetMappedRange with start/end offsets. +// From the go/token domain, call safetoken.Offsets first, +// or use a helper such as ParsedGoFile.MappedPosRange. +// +// Two MappedRanges produced the same Mapper are equal if and only if they +// denote the same range. Two MappedRanges produced by different Mappers +// are unequal even when they represent the same range of the same file. +type MappedRange struct { + Mapper *Mapper + start, end int // valid byte offsets: 0 <= start <= end <= len(Mapper.Content) +} + +// Offsets returns the (start, end) byte offsets of this range. +func (mr MappedRange) Offsets() (start, end int) { return mr.start, mr.end } + +// -- convenience functions -- + +// URI returns the URI of the range's file. +func (mr MappedRange) URI() span.URI { + return mr.Mapper.URI +} + +// Range returns the range in protocol (UTF-16) form. +func (mr MappedRange) Range() Range { + rng, err := mr.Mapper.OffsetRange(mr.start, mr.end) + if err != nil { + panic(err) // can't happen + } + return rng +} + +// Location returns the range in protocol location (UTF-16) form. +func (mr MappedRange) Location() Location { + return mr.Mapper.RangeLocation(mr.Range()) +} + +// Span returns the range in span (UTF-8) form. +func (mr MappedRange) Span() span.Span { + spn, err := mr.Mapper.OffsetSpan(mr.start, mr.end) + if err != nil { + panic(err) // can't happen + } + return spn +} + +// String formats the range in span (UTF-8) notation. +func (mr MappedRange) String() string { + return fmt.Sprint(mr.Span()) +} + +// LocationTextDocumentPositionParams converts its argument to its result. +func LocationTextDocumentPositionParams(loc Location) TextDocumentPositionParams { + return TextDocumentPositionParams{ + TextDocument: TextDocumentIdentifier{URI: loc.URI}, + Position: loc.Range.Start, + } +} diff --git a/gopls/internal/lsp/protocol/mapper_test.go b/gopls/internal/lsp/protocol/mapper_test.go new file mode 100644 index 000000000..0780491de --- /dev/null +++ b/gopls/internal/lsp/protocol/mapper_test.go @@ -0,0 +1,441 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol_test + +import ( + "fmt" + "strings" + "testing" + + "golang.org/x/tools/gopls/internal/lsp/protocol" + "golang.org/x/tools/gopls/internal/span" +) + +// This file tests Mapper's logic for converting between +// span.Point and UTF-16 columns. (The strange form attests to an +// earlier abstraction.) + +// 𐐀 is U+10400 = [F0 90 90 80] in UTF-8, [D801 DC00] in UTF-16. +var funnyString = []byte("𐐀23\n𐐀45") + +var toUTF16Tests = []struct { + scenario string + input []byte + line int // 1-indexed count + col int // 1-indexed byte position in line + offset int // 0-indexed byte offset into input + resUTF16col int // 1-indexed UTF-16 col number + pre string // everything before the cursor on the line + post string // everything from the cursor onwards + err string // expected error string in call to ToUTF16Column + issue *bool +}{ + { + scenario: "cursor missing content", + input: nil, + offset: -1, + err: "point has neither offset nor line/column", + }, + { + scenario: "cursor missing position", + input: funnyString, + line: -1, + col: -1, + offset: -1, + err: "point has neither offset nor line/column", + }, + { + scenario: "zero length input; cursor at first col, first line", + input: []byte(""), + line: 1, + col: 1, + offset: 0, + resUTF16col: 1, + }, + { + scenario: "cursor before funny character; first line", + input: funnyString, + line: 1, + col: 1, + offset: 0, + resUTF16col: 1, + pre: "", + post: "𐐀23", + }, + { + scenario: "cursor after funny character; first line", + input: funnyString, + line: 1, + col: 5, // 4 + 1 (1-indexed) + offset: 4, // (unused since we have line+col) + resUTF16col: 3, // 2 + 1 (1-indexed) + pre: "𐐀", + post: "23", + }, + { + scenario: "cursor after last character on first line", + input: funnyString, + line: 1, + col: 7, // 4 + 1 + 1 + 1 (1-indexed) + offset: 6, // 4 + 1 + 1 (unused since we have line+col) + resUTF16col: 5, // 2 + 1 + 1 + 1 (1-indexed) + pre: "𐐀23", + post: "", + }, + { + scenario: "cursor before funny character; second line", + input: funnyString, + line: 2, + col: 1, + offset: 7, // length of first line (unused since we have line+col) + resUTF16col: 1, + pre: "", + post: "𐐀45", + }, + { + scenario: "cursor after funny character; second line", + input: funnyString, + line: 1, + col: 5, // 4 + 1 (1-indexed) + offset: 11, // 7 (length of first line) + 4 (unused since we have line+col) + resUTF16col: 3, // 2 + 1 (1-indexed) + pre: "𐐀", + post: "45", + }, + { + scenario: "cursor after last character on second line", + input: funnyString, + line: 2, + col: 7, // 4 + 1 + 1 + 1 (1-indexed) + offset: 13, // 7 (length of first line) + 4 + 1 + 1 (unused since we have line+col) + resUTF16col: 5, // 2 + 1 + 1 + 1 (1-indexed) + pre: "𐐀45", + post: "", + }, + { + scenario: "cursor beyond end of file", + input: funnyString, + line: 2, + col: 8, // 4 + 1 + 1 + 1 + 1 (1-indexed) + offset: 14, // 4 + 1 + 1 + 1 (unused since we have line+col) + err: "column is beyond end of file", + }, +} + +var fromUTF16Tests = []struct { + scenario string + input []byte + line int // 1-indexed line number (isn't actually used) + utf16col int // 1-indexed UTF-16 col number + resCol int // 1-indexed byte position in line + resOffset int // 0-indexed byte offset into input + pre string // everything before the cursor on the line + post string // everything from the cursor onwards + err string // expected error string in call to ToUTF16Column +}{ + { + scenario: "zero length input; cursor at first col, first line", + input: []byte(""), + line: 1, + utf16col: 1, + resCol: 1, + resOffset: 0, + pre: "", + post: "", + }, + { + scenario: "cursor before funny character", + input: funnyString, + line: 1, + utf16col: 1, + resCol: 1, + resOffset: 0, + pre: "", + post: "𐐀23", + }, + { + scenario: "cursor after funny character", + input: funnyString, + line: 1, + utf16col: 3, + resCol: 5, + resOffset: 4, + pre: "𐐀", + post: "23", + }, + { + scenario: "cursor after last character on line", + input: funnyString, + line: 1, + utf16col: 5, + resCol: 7, + resOffset: 6, + pre: "𐐀23", + post: "", + }, + { + scenario: "cursor beyond last character on line", + input: funnyString, + line: 1, + utf16col: 6, + resCol: 7, + resOffset: 6, + pre: "𐐀23", + post: "", + err: "column is beyond end of line", + }, + { + scenario: "cursor before funny character; second line", + input: funnyString, + line: 2, + utf16col: 1, + resCol: 1, + resOffset: 7, + pre: "", + post: "𐐀45", + }, + { + scenario: "cursor after funny character; second line", + input: funnyString, + line: 2, + utf16col: 3, // 2 + 1 (1-indexed) + resCol: 5, // 4 + 1 (1-indexed) + resOffset: 11, // 7 (length of first line) + 4 + pre: "𐐀", + post: "45", + }, + { + scenario: "cursor after last character on second line", + input: funnyString, + line: 2, + utf16col: 5, // 2 + 1 + 1 + 1 (1-indexed) + resCol: 7, // 4 + 1 + 1 + 1 (1-indexed) + resOffset: 13, // 7 (length of first line) + 4 + 1 + 1 + pre: "𐐀45", + post: "", + }, + { + scenario: "cursor beyond end of file", + input: funnyString, + line: 2, + utf16col: 6, // 2 + 1 + 1 + 1 + 1(1-indexed) + resCol: 8, // 4 + 1 + 1 + 1 + 1 (1-indexed) + resOffset: 14, // 7 (length of first line) + 4 + 1 + 1 + 1 + err: "column is beyond end of file", + }, +} + +func TestToUTF16(t *testing.T) { + for _, e := range toUTF16Tests { + t.Run(e.scenario, func(t *testing.T) { + if e.issue != nil && !*e.issue { + t.Skip("expected to fail") + } + p := span.NewPoint(e.line, e.col, e.offset) + m := protocol.NewMapper("", e.input) + pos, err := m.PointPosition(p) + if err != nil { + if err.Error() != e.err { + t.Fatalf("expected error %v; got %v", e.err, err) + } + return + } + if e.err != "" { + t.Fatalf("unexpected success; wanted %v", e.err) + } + got := int(pos.Character) + 1 + if got != e.resUTF16col { + t.Fatalf("expected result %v; got %v", e.resUTF16col, got) + } + pre, post := getPrePost(e.input, p.Offset()) + if string(pre) != e.pre { + t.Fatalf("expected #%d pre %q; got %q", p.Offset(), e.pre, pre) + } + if string(post) != e.post { + t.Fatalf("expected #%d, post %q; got %q", p.Offset(), e.post, post) + } + }) + } +} + +func TestFromUTF16(t *testing.T) { + for _, e := range fromUTF16Tests { + t.Run(e.scenario, func(t *testing.T) { + m := protocol.NewMapper("", []byte(e.input)) + p, err := m.PositionPoint(protocol.Position{ + Line: uint32(e.line - 1), + Character: uint32(e.utf16col - 1), + }) + if err != nil { + if err.Error() != e.err { + t.Fatalf("expected error %v; got %v", e.err, err) + } + return + } + if e.err != "" { + t.Fatalf("unexpected success; wanted %v", e.err) + } + if p.Column() != e.resCol { + t.Fatalf("expected resulting col %v; got %v", e.resCol, p.Column()) + } + if p.Offset() != e.resOffset { + t.Fatalf("expected resulting offset %v; got %v", e.resOffset, p.Offset()) + } + pre, post := getPrePost(e.input, p.Offset()) + if string(pre) != e.pre { + t.Fatalf("expected #%d pre %q; got %q", p.Offset(), e.pre, pre) + } + if string(post) != e.post { + t.Fatalf("expected #%d post %q; got %q", p.Offset(), e.post, post) + } + }) + } +} + +func getPrePost(content []byte, offset int) (string, string) { + pre, post := string(content)[:offset], string(content)[offset:] + if i := strings.LastIndex(pre, "\n"); i >= 0 { + pre = pre[i+1:] + } + if i := strings.IndexRune(post, '\n'); i >= 0 { + post = post[:i] + } + return pre, post +} + +// -- these are the historical lsppos tests -- + +type testCase struct { + content string // input text + substrOrOffset interface{} // explicit integer offset, or a substring + wantLine, wantChar int // expected LSP position information +} + +// offset returns the test case byte offset +func (c testCase) offset() int { + switch x := c.substrOrOffset.(type) { + case int: + return x + case string: + i := strings.Index(c.content, x) + if i < 0 { + panic(fmt.Sprintf("%q does not contain substring %q", c.content, x)) + } + return i + } + panic("substrOrIndex must be an integer or string") +} + +var tests = []testCase{ + {"a𐐀b", "a", 0, 0}, + {"a𐐀b", "𐐀", 0, 1}, + {"a𐐀b", "b", 0, 3}, + {"a𐐀b\n", "\n", 0, 4}, + {"a𐐀b\r\n", "\n", 0, 4}, // \r|\n is not a valid position, so we move back to the end of the first line. + {"a𐐀b\r\nx", "x", 1, 0}, + {"a𐐀b\r\nx\ny", "y", 2, 0}, + + // Testing EOL and EOF positions + {"", 0, 0, 0}, // 0th position of an empty buffer is (0, 0) + {"abc", "c", 0, 2}, + {"abc", 3, 0, 3}, + {"abc\n", "\n", 0, 3}, + {"abc\n", 4, 1, 0}, // position after a newline is on the next line +} + +func TestLineChar(t *testing.T) { + for _, test := range tests { + m := protocol.NewMapper("", []byte(test.content)) + offset := test.offset() + posn, _ := m.OffsetPosition(offset) + gotLine, gotChar := int(posn.Line), int(posn.Character) + if gotLine != test.wantLine || gotChar != test.wantChar { + t.Errorf("LineChar(%d) = (%d,%d), want (%d,%d)", offset, gotLine, gotChar, test.wantLine, test.wantChar) + } + } +} + +func TestInvalidOffset(t *testing.T) { + content := []byte("a𐐀b\r\nx\ny") + m := protocol.NewMapper("", content) + for _, offset := range []int{-1, 100} { + posn, err := m.OffsetPosition(offset) + if err == nil { + t.Errorf("OffsetPosition(%d) = %s, want error", offset, posn) + } + } +} + +func TestPosition(t *testing.T) { + for _, test := range tests { + m := protocol.NewMapper("", []byte(test.content)) + offset := test.offset() + got, err := m.OffsetPosition(offset) + if err != nil { + t.Errorf("OffsetPosition(%d) failed: %v", offset, err) + continue + } + want := protocol.Position{Line: uint32(test.wantLine), Character: uint32(test.wantChar)} + if got != want { + t.Errorf("Position(%d) = %v, want %v", offset, got, want) + } + } +} + +func TestRange(t *testing.T) { + for _, test := range tests { + m := protocol.NewMapper("", []byte(test.content)) + offset := test.offset() + got, err := m.OffsetRange(0, offset) + if err != nil { + t.Fatal(err) + } + want := protocol.Range{ + End: protocol.Position{Line: uint32(test.wantLine), Character: uint32(test.wantChar)}, + } + if got != want { + t.Errorf("Range(%d) = %v, want %v", offset, got, want) + } + } +} + +func TestBytesOffset(t *testing.T) { + tests := []struct { + text string + pos protocol.Position + want int + }{ + // U+10400 encodes as [F0 90 90 80] in UTF-8 and [D801 DC00] in UTF-16. + {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 0}, want: 0}, + {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 1}, want: 1}, + {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 2}, want: 1}, + {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 3}, want: 5}, + {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 4}, want: 6}, + {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 5}, want: -1}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 0, Character: 3}, want: 3}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 0, Character: 4}, want: -1}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 1, Character: 0}, want: 4}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 1, Character: 3}, want: 7}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 1, Character: 4}, want: -1}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 2, Character: 0}, want: 8}, + {text: "aaa\nbbb\n", pos: protocol.Position{Line: 2, Character: 1}, want: -1}, + {text: "aaa\nbbb\n\n", pos: protocol.Position{Line: 2, Character: 0}, want: 8}, + } + + for i, test := range tests { + fname := fmt.Sprintf("test %d", i) + uri := span.URIFromPath(fname) + mapper := protocol.NewMapper(uri, []byte(test.text)) + got, err := mapper.PositionPoint(test.pos) + if err != nil && test.want != -1 { + t.Errorf("%d: unexpected error: %v", i, err) + } + if err == nil && got.Offset() != test.want { + t.Errorf("want %d for %q(Line:%d,Character:%d), but got %d", test.want, test.text, int(test.pos.Line), int(test.pos.Character), got.Offset()) + } + } +} + +// -- end -- diff --git a/gopls/internal/lsp/protocol/protocol.go b/gopls/internal/lsp/protocol/protocol.go new file mode 100644 index 000000000..7ca8f2bc6 --- /dev/null +++ b/gopls/internal/lsp/protocol/protocol.go @@ -0,0 +1,284 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +import ( + "context" + "encoding/json" + "fmt" + "io" + + "golang.org/x/tools/internal/event" + "golang.org/x/tools/internal/jsonrpc2" + jsonrpc2_v2 "golang.org/x/tools/internal/jsonrpc2_v2" + "golang.org/x/tools/internal/xcontext" +) + +var ( + // RequestCancelledError should be used when a request is cancelled early. + RequestCancelledError = jsonrpc2.NewError(-32800, "JSON RPC cancelled") + RequestCancelledErrorV2 = jsonrpc2_v2.NewError(-32800, "JSON RPC cancelled") +) + +type ClientCloser interface { + Client + io.Closer +} + +type connSender interface { + io.Closer + + Notify(ctx context.Context, method string, params interface{}) error + Call(ctx context.Context, method string, params, result interface{}) error +} + +type clientDispatcher struct { + sender connSender +} + +func (c *clientDispatcher) Close() error { + return c.sender.Close() +} + +// ClientDispatcher returns a Client that dispatches LSP requests across the +// given jsonrpc2 connection. +func ClientDispatcher(conn jsonrpc2.Conn) ClientCloser { + return &clientDispatcher{sender: clientConn{conn}} +} + +type clientConn struct { + conn jsonrpc2.Conn +} + +func (c clientConn) Close() error { + return c.conn.Close() +} + +func (c clientConn) Notify(ctx context.Context, method string, params interface{}) error { + return c.conn.Notify(ctx, method, params) +} + +func (c clientConn) Call(ctx context.Context, method string, params interface{}, result interface{}) error { + id, err := c.conn.Call(ctx, method, params, result) + if ctx.Err() != nil { + cancelCall(ctx, c, id) + } + return err +} + +func ClientDispatcherV2(conn *jsonrpc2_v2.Connection) ClientCloser { + return &clientDispatcher{clientConnV2{conn}} +} + +type clientConnV2 struct { + conn *jsonrpc2_v2.Connection +} + +func (c clientConnV2) Close() error { + return c.conn.Close() +} + +func (c clientConnV2) Notify(ctx context.Context, method string, params interface{}) error { + return c.conn.Notify(ctx, method, params) +} + +func (c clientConnV2) Call(ctx context.Context, method string, params interface{}, result interface{}) error { + call := c.conn.Call(ctx, method, params) + err := call.Await(ctx, result) + if ctx.Err() != nil { + detached := xcontext.Detach(ctx) + c.conn.Notify(detached, "$/cancelRequest", &CancelParams{ID: call.ID().Raw()}) + } + return err +} + +// ServerDispatcher returns a Server that dispatches LSP requests across the +// given jsonrpc2 connection. +func ServerDispatcher(conn jsonrpc2.Conn) Server { + return &serverDispatcher{sender: clientConn{conn}} +} + +func ServerDispatcherV2(conn *jsonrpc2_v2.Connection) Server { + return &serverDispatcher{sender: clientConnV2{conn}} +} + +type serverDispatcher struct { + sender connSender +} + +func ClientHandler(client Client, handler jsonrpc2.Handler) jsonrpc2.Handler { + return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error { + if ctx.Err() != nil { + ctx := xcontext.Detach(ctx) + return reply(ctx, nil, RequestCancelledError) + } + handled, err := clientDispatch(ctx, client, reply, req) + if handled || err != nil { + return err + } + return handler(ctx, reply, req) + } +} + +func ClientHandlerV2(client Client) jsonrpc2_v2.Handler { + return jsonrpc2_v2.HandlerFunc(func(ctx context.Context, req *jsonrpc2_v2.Request) (interface{}, error) { + if ctx.Err() != nil { + return nil, RequestCancelledErrorV2 + } + req1 := req2to1(req) + var ( + result interface{} + resErr error + ) + replier := func(_ context.Context, res interface{}, err error) error { + if err != nil { + resErr = err + return nil + } + result = res + return nil + } + _, err := clientDispatch(ctx, client, replier, req1) + if err != nil { + return nil, err + } + return result, resErr + }) +} + +func ServerHandler(server Server, handler jsonrpc2.Handler) jsonrpc2.Handler { + return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error { + if ctx.Err() != nil { + ctx := xcontext.Detach(ctx) + return reply(ctx, nil, RequestCancelledError) + } + handled, err := serverDispatch(ctx, server, reply, req) + if handled || err != nil { + return err + } + //TODO: This code is wrong, it ignores handler and assumes non standard + // request handles everything + // non standard request should just be a layered handler. + var params interface{} + if err := json.Unmarshal(req.Params(), ¶ms); err != nil { + return sendParseError(ctx, reply, err) + } + resp, err := server.NonstandardRequest(ctx, req.Method(), params) + return reply(ctx, resp, err) + + } +} + +func ServerHandlerV2(server Server) jsonrpc2_v2.Handler { + return jsonrpc2_v2.HandlerFunc(func(ctx context.Context, req *jsonrpc2_v2.Request) (interface{}, error) { + if ctx.Err() != nil { + return nil, RequestCancelledErrorV2 + } + req1 := req2to1(req) + var ( + result interface{} + resErr error + ) + replier := func(_ context.Context, res interface{}, err error) error { + if err != nil { + resErr = err + return nil + } + result = res + return nil + } + _, err := serverDispatch(ctx, server, replier, req1) + if err != nil { + return nil, err + } + return result, resErr + }) +} + +func req2to1(req2 *jsonrpc2_v2.Request) jsonrpc2.Request { + if req2.ID.IsValid() { + raw := req2.ID.Raw() + var idv1 jsonrpc2.ID + switch v := raw.(type) { + case int64: + idv1 = jsonrpc2.NewIntID(v) + case string: + idv1 = jsonrpc2.NewStringID(v) + default: + panic(fmt.Sprintf("unsupported ID type %T", raw)) + } + req1, err := jsonrpc2.NewCall(idv1, req2.Method, req2.Params) + if err != nil { + panic(err) + } + return req1 + } + req1, err := jsonrpc2.NewNotification(req2.Method, req2.Params) + if err != nil { + panic(err) + } + return req1 +} + +func Handlers(handler jsonrpc2.Handler) jsonrpc2.Handler { + return CancelHandler( + jsonrpc2.AsyncHandler( + jsonrpc2.MustReplyHandler(handler))) +} + +func CancelHandler(handler jsonrpc2.Handler) jsonrpc2.Handler { + handler, canceller := jsonrpc2.CancelHandler(handler) + return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error { + if req.Method() != "$/cancelRequest" { + // TODO(iancottrell): See if we can generate a reply for the request to be cancelled + // at the point of cancellation rather than waiting for gopls to naturally reply. + // To do that, we need to keep track of whether a reply has been sent already and + // be careful about racing between the two paths. + // TODO(iancottrell): Add a test that watches the stream and verifies the response + // for the cancelled request flows. + replyWithDetachedContext := func(ctx context.Context, resp interface{}, err error) error { + // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest + if ctx.Err() != nil && err == nil { + err = RequestCancelledError + } + ctx = xcontext.Detach(ctx) + return reply(ctx, resp, err) + } + return handler(ctx, replyWithDetachedContext, req) + } + var params CancelParams + if err := json.Unmarshal(req.Params(), ¶ms); err != nil { + return sendParseError(ctx, reply, err) + } + if n, ok := params.ID.(float64); ok { + canceller(jsonrpc2.NewIntID(int64(n))) + } else if s, ok := params.ID.(string); ok { + canceller(jsonrpc2.NewStringID(s)) + } else { + return sendParseError(ctx, reply, fmt.Errorf("request ID %v malformed", params.ID)) + } + return reply(ctx, nil, nil) + } +} + +func Call(ctx context.Context, conn jsonrpc2.Conn, method string, params interface{}, result interface{}) error { + id, err := conn.Call(ctx, method, params, result) + if ctx.Err() != nil { + cancelCall(ctx, clientConn{conn}, id) + } + return err +} + +func cancelCall(ctx context.Context, sender connSender, id jsonrpc2.ID) { + ctx = xcontext.Detach(ctx) + ctx, done := event.Start(ctx, "protocol.canceller") + defer done() + // Note that only *jsonrpc2.ID implements json.Marshaler. + sender.Notify(ctx, "$/cancelRequest", &CancelParams{ID: &id}) +} + +func sendParseError(ctx context.Context, reply jsonrpc2.Replier, err error) error { + return reply(ctx, nil, fmt.Errorf("%w: %s", jsonrpc2.ErrParse, err)) +} diff --git a/gopls/internal/lsp/protocol/span.go b/gopls/internal/lsp/protocol/span.go new file mode 100644 index 000000000..d484f8f74 --- /dev/null +++ b/gopls/internal/lsp/protocol/span.go @@ -0,0 +1,118 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +import ( + "fmt" + "unicode/utf8" + + "golang.org/x/tools/gopls/internal/span" +) + +func URIFromSpanURI(uri span.URI) DocumentURI { + return DocumentURI(uri) // simple conversion +} + +func URIFromPath(path string) DocumentURI { + return URIFromSpanURI(span.URIFromPath(path)) // normalizing conversion +} + +func (u DocumentURI) SpanURI() span.URI { + return span.URIFromURI(string(u)) // normalizing conversion +} + +func IsPoint(r Range) bool { + return r.Start.Line == r.End.Line && r.Start.Character == r.End.Character +} + +// CompareLocation defines a three-valued comparison over locations, +// lexicographically ordered by (URI, Range). +func CompareLocation(x, y Location) int { + if x.URI != y.URI { + if x.URI < y.URI { + return -1 + } else { + return +1 + } + } + return CompareRange(x.Range, y.Range) +} + +// CompareRange returns -1 if a is before b, 0 if a == b, and 1 if a is after b. +// +// A range a is defined to be 'before' b if a.Start is before b.Start, or +// a.Start == b.Start and a.End is before b.End. +func CompareRange(a, b Range) int { + if r := ComparePosition(a.Start, b.Start); r != 0 { + return r + } + return ComparePosition(a.End, b.End) +} + +// ComparePosition returns -1 if a is before b, 0 if a == b, and 1 if a is after b. +func ComparePosition(a, b Position) int { + if a.Line != b.Line { + if a.Line < b.Line { + return -1 + } else { + return +1 + } + } + if a.Character != b.Character { + if a.Character < b.Character { + return -1 + } else { + return +1 + } + } + return 0 +} + +func Intersect(a, b Range) bool { + if a.Start.Line > b.End.Line || a.End.Line < b.Start.Line { + return false + } + return !((a.Start.Line == b.End.Line) && a.Start.Character > b.End.Character || + (a.End.Line == b.Start.Line) && a.End.Character < b.Start.Character) +} + +// Format implements fmt.Formatter. +// +// Note: Formatter is implemented instead of Stringer (presumably) for +// performance reasons, though it is not clear that it matters in practice. +func (r Range) Format(f fmt.State, _ rune) { + fmt.Fprintf(f, "%v-%v", r.Start, r.End) +} + +// Format implements fmt.Formatter. +// +// See Range.Format for discussion of why the Formatter interface is +// implemented rather than Stringer. +func (p Position) Format(f fmt.State, _ rune) { + fmt.Fprintf(f, "%v:%v", p.Line, p.Character) +} + +// -- implementation helpers -- + +// UTF16Len returns the number of codes in the UTF-16 transcoding of s. +func UTF16Len(s []byte) int { + var n int + for len(s) > 0 { + n++ + + // Fast path for ASCII. + if s[0] < 0x80 { + s = s[1:] + continue + } + + r, size := utf8.DecodeRune(s) + if r >= 0x10000 { + n++ // surrogate pair + } + s = s[size:] + } + return n +} diff --git a/gopls/internal/lsp/protocol/tsclient.go b/gopls/internal/lsp/protocol/tsclient.go new file mode 100644 index 000000000..cfafecfdc --- /dev/null +++ b/gopls/internal/lsp/protocol/tsclient.go @@ -0,0 +1,249 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated for LSP. DO NOT EDIT. + +package protocol + +// Code generated from protocol/metaModel.json at ref release/protocol/3.17.3-next.6 (hash 56c23c557e3568a9f56f42435fd5a80f9458957f). +// https://github.com/microsoft/vscode-languageserver-node/blob/release/protocol/3.17.3-next.6/protocol/metaModel.json +// LSP metaData.version = 3.17.0. + +import ( + "context" + "encoding/json" + + "golang.org/x/tools/internal/jsonrpc2" +) + +type Client interface { + LogTrace(context.Context, *LogTraceParams) error // $/logTrace + Progress(context.Context, *ProgressParams) error // $/progress + RegisterCapability(context.Context, *RegistrationParams) error // client/registerCapability + UnregisterCapability(context.Context, *UnregistrationParams) error // client/unregisterCapability + Event(context.Context, *interface{}) error // telemetry/event + PublishDiagnostics(context.Context, *PublishDiagnosticsParams) error // textDocument/publishDiagnostics + LogMessage(context.Context, *LogMessageParams) error // window/logMessage + ShowDocument(context.Context, *ShowDocumentParams) (*ShowDocumentResult, error) // window/showDocument + ShowMessage(context.Context, *ShowMessageParams) error // window/showMessage + ShowMessageRequest(context.Context, *ShowMessageRequestParams) (*MessageActionItem, error) // window/showMessageRequest + WorkDoneProgressCreate(context.Context, *WorkDoneProgressCreateParams) error // window/workDoneProgress/create + ApplyEdit(context.Context, *ApplyWorkspaceEditParams) (*ApplyWorkspaceEditResult, error) // workspace/applyEdit + CodeLensRefresh(context.Context) error // workspace/codeLens/refresh + Configuration(context.Context, *ParamConfiguration) ([]LSPAny, error) // workspace/configuration + DiagnosticRefresh(context.Context) error // workspace/diagnostic/refresh + InlayHintRefresh(context.Context) error // workspace/inlayHint/refresh + InlineValueRefresh(context.Context) error // workspace/inlineValue/refresh + SemanticTokensRefresh(context.Context) error // workspace/semanticTokens/refresh + WorkspaceFolders(context.Context) ([]WorkspaceFolder, error) // workspace/workspaceFolders +} + +func clientDispatch(ctx context.Context, client Client, reply jsonrpc2.Replier, r jsonrpc2.Request) (bool, error) { + switch r.Method() { + case "$/logTrace": + var params LogTraceParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.LogTrace(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "$/progress": + var params ProgressParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.Progress(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "client/registerCapability": + var params RegistrationParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.RegisterCapability(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "client/unregisterCapability": + var params UnregistrationParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.UnregisterCapability(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "telemetry/event": + var params interface{} + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.Event(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "textDocument/publishDiagnostics": + var params PublishDiagnosticsParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.PublishDiagnostics(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "window/logMessage": + var params LogMessageParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.LogMessage(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "window/showDocument": + var params ShowDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := client.ShowDocument(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "window/showMessage": + var params ShowMessageParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.ShowMessage(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "window/showMessageRequest": + var params ShowMessageRequestParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := client.ShowMessageRequest(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "window/workDoneProgress/create": + var params WorkDoneProgressCreateParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := client.WorkDoneProgressCreate(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/applyEdit": + var params ApplyWorkspaceEditParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := client.ApplyEdit(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/codeLens/refresh": + err := client.CodeLensRefresh(ctx) + return true, reply(ctx, nil, err) + case "workspace/configuration": + var params ParamConfiguration + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := client.Configuration(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/diagnostic/refresh": + err := client.DiagnosticRefresh(ctx) + return true, reply(ctx, nil, err) + case "workspace/inlayHint/refresh": + err := client.InlayHintRefresh(ctx) + return true, reply(ctx, nil, err) + case "workspace/inlineValue/refresh": + err := client.InlineValueRefresh(ctx) + return true, reply(ctx, nil, err) + case "workspace/semanticTokens/refresh": + err := client.SemanticTokensRefresh(ctx) + return true, reply(ctx, nil, err) + case "workspace/workspaceFolders": + resp, err := client.WorkspaceFolders(ctx) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + default: + return false, nil + } +} + +func (s *clientDispatcher) LogTrace(ctx context.Context, params *LogTraceParams) error { + return s.sender.Notify(ctx, "$/logTrace", params) +} +func (s *clientDispatcher) Progress(ctx context.Context, params *ProgressParams) error { + return s.sender.Notify(ctx, "$/progress", params) +} +func (s *clientDispatcher) RegisterCapability(ctx context.Context, params *RegistrationParams) error { + return s.sender.Call(ctx, "client/registerCapability", params, nil) +} +func (s *clientDispatcher) UnregisterCapability(ctx context.Context, params *UnregistrationParams) error { + return s.sender.Call(ctx, "client/unregisterCapability", params, nil) +} +func (s *clientDispatcher) Event(ctx context.Context, params *interface{}) error { + return s.sender.Notify(ctx, "telemetry/event", params) +} +func (s *clientDispatcher) PublishDiagnostics(ctx context.Context, params *PublishDiagnosticsParams) error { + return s.sender.Notify(ctx, "textDocument/publishDiagnostics", params) +} +func (s *clientDispatcher) LogMessage(ctx context.Context, params *LogMessageParams) error { + return s.sender.Notify(ctx, "window/logMessage", params) +} +func (s *clientDispatcher) ShowDocument(ctx context.Context, params *ShowDocumentParams) (*ShowDocumentResult, error) { + var result *ShowDocumentResult + if err := s.sender.Call(ctx, "window/showDocument", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *clientDispatcher) ShowMessage(ctx context.Context, params *ShowMessageParams) error { + return s.sender.Notify(ctx, "window/showMessage", params) +} +func (s *clientDispatcher) ShowMessageRequest(ctx context.Context, params *ShowMessageRequestParams) (*MessageActionItem, error) { + var result *MessageActionItem + if err := s.sender.Call(ctx, "window/showMessageRequest", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *clientDispatcher) WorkDoneProgressCreate(ctx context.Context, params *WorkDoneProgressCreateParams) error { + return s.sender.Call(ctx, "window/workDoneProgress/create", params, nil) +} +func (s *clientDispatcher) ApplyEdit(ctx context.Context, params *ApplyWorkspaceEditParams) (*ApplyWorkspaceEditResult, error) { + var result *ApplyWorkspaceEditResult + if err := s.sender.Call(ctx, "workspace/applyEdit", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *clientDispatcher) CodeLensRefresh(ctx context.Context) error { + return s.sender.Call(ctx, "workspace/codeLens/refresh", nil, nil) +} +func (s *clientDispatcher) Configuration(ctx context.Context, params *ParamConfiguration) ([]LSPAny, error) { + var result []LSPAny + if err := s.sender.Call(ctx, "workspace/configuration", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *clientDispatcher) DiagnosticRefresh(ctx context.Context) error { + return s.sender.Call(ctx, "workspace/diagnostic/refresh", nil, nil) +} +func (s *clientDispatcher) InlayHintRefresh(ctx context.Context) error { + return s.sender.Call(ctx, "workspace/inlayHint/refresh", nil, nil) +} +func (s *clientDispatcher) InlineValueRefresh(ctx context.Context) error { + return s.sender.Call(ctx, "workspace/inlineValue/refresh", nil, nil) +} +func (s *clientDispatcher) SemanticTokensRefresh(ctx context.Context) error { + return s.sender.Call(ctx, "workspace/semanticTokens/refresh", nil, nil) +} +func (s *clientDispatcher) WorkspaceFolders(ctx context.Context) ([]WorkspaceFolder, error) { + var result []WorkspaceFolder + if err := s.sender.Call(ctx, "workspace/workspaceFolders", nil, &result); err != nil { + return nil, err + } + return result, nil +} diff --git a/gopls/internal/lsp/protocol/tsdocument_changes.go b/gopls/internal/lsp/protocol/tsdocument_changes.go new file mode 100644 index 000000000..2c7a524e1 --- /dev/null +++ b/gopls/internal/lsp/protocol/tsdocument_changes.go @@ -0,0 +1,42 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package protocol + +import ( + "encoding/json" + "fmt" +) + +// DocumentChanges is a union of a file edit and directory rename operations +// for package renaming feature. At most one field of this struct is non-nil. +type DocumentChanges struct { + TextDocumentEdit *TextDocumentEdit + RenameFile *RenameFile +} + +func (d *DocumentChanges) UnmarshalJSON(data []byte) error { + var m map[string]interface{} + + if err := json.Unmarshal(data, &m); err != nil { + return err + } + + if _, ok := m["textDocument"]; ok { + d.TextDocumentEdit = new(TextDocumentEdit) + return json.Unmarshal(data, d.TextDocumentEdit) + } + + d.RenameFile = new(RenameFile) + return json.Unmarshal(data, d.RenameFile) +} + +func (d *DocumentChanges) MarshalJSON() ([]byte, error) { + if d.TextDocumentEdit != nil { + return json.Marshal(d.TextDocumentEdit) + } else if d.RenameFile != nil { + return json.Marshal(d.RenameFile) + } + return nil, fmt.Errorf("Empty DocumentChanges union value") +} diff --git a/gopls/internal/lsp/protocol/tsjson.go b/gopls/internal/lsp/protocol/tsjson.go new file mode 100644 index 000000000..320fa0838 --- /dev/null +++ b/gopls/internal/lsp/protocol/tsjson.go @@ -0,0 +1,1997 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated for LSP. DO NOT EDIT. + +package protocol + +// Code generated from protocol/metaModel.json at ref release/protocol/3.17.3-next.6 (hash 56c23c557e3568a9f56f42435fd5a80f9458957f). +// https://github.com/microsoft/vscode-languageserver-node/blob/release/protocol/3.17.3-next.6/protocol/metaModel.json +// LSP metaData.version = 3.17.0. + +import "encoding/json" + +import "fmt" + +// UnmarshalError indicates that a JSON value did not conform to +// one of the expected cases of an LSP union type. +type UnmarshalError struct { + msg string +} + +func (e UnmarshalError) Error() string { + return e.msg +} + +// from line 4769 +func (t OrFEditRangePItemDefaults) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FEditRangePItemDefaults: + return json.Marshal(x) + case Range: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FEditRangePItemDefaults Range]", t) +} + +func (t *OrFEditRangePItemDefaults) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FEditRangePItemDefaults + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 Range + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FEditRangePItemDefaults Range]"} +} + +// from line 9811 +func (t OrFNotebookPNotebookSelector) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case NotebookDocumentFilter: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilter string]", t) +} + +func (t *OrFNotebookPNotebookSelector) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 NotebookDocumentFilter + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilter string]"} +} + +// from line 5520 +func (t OrPLocation_workspace_symbol) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case Location: + return json.Marshal(x) + case PLocationMsg_workspace_symbol: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [Location PLocationMsg_workspace_symbol]", t) +} + +func (t *OrPLocation_workspace_symbol) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 Location + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 PLocationMsg_workspace_symbol + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [Location PLocationMsg_workspace_symbol]"} +} + +// from line 4163 +func (t OrPSection_workspace_didChangeConfiguration) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case []string: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [[]string string]", t) +} + +func (t *OrPSection_workspace_didChangeConfiguration) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 []string + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [[]string string]"} +} + +// from line 7075 +func (t OrPTooltipPLabel) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case MarkupContent: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t) +} + +func (t *OrPTooltipPLabel) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 MarkupContent + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"} +} + +// from line 3699 +func (t OrPTooltip_textDocument_inlayHint) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case MarkupContent: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t) +} + +func (t *OrPTooltip_textDocument_inlayHint) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 MarkupContent + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"} +} + +// from line 6184 +func (t Or_CancelParams_id) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case int32: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [int32 string]", t) +} + +func (t *Or_CancelParams_id) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 int32 + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [int32 string]"} +} + +// from line 4582 +func (t Or_CompletionItem_documentation) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case MarkupContent: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t) +} + +func (t *Or_CompletionItem_documentation) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 MarkupContent + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"} +} + +// from line 4665 +func (t Or_CompletionItem_textEdit) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case InsertReplaceEdit: + return json.Marshal(x) + case TextEdit: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [InsertReplaceEdit TextEdit]", t) +} + +func (t *Or_CompletionItem_textEdit) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 InsertReplaceEdit + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 TextEdit + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [InsertReplaceEdit TextEdit]"} +} + +// from line 13753 +func (t Or_Definition) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case Location: + return json.Marshal(x) + case []Location: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [Location []Location]", t) +} + +func (t *Or_Definition) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 Location + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 []Location + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [Location []Location]"} +} + +// from line 8547 +func (t Or_Diagnostic_code) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case int32: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [int32 string]", t) +} + +func (t *Or_Diagnostic_code) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 int32 + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [int32 string]"} +} + +// from line 13885 +func (t Or_DocumentDiagnosticReport) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case RelatedFullDocumentDiagnosticReport: + return json.Marshal(x) + case RelatedUnchangedDocumentDiagnosticReport: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [RelatedFullDocumentDiagnosticReport RelatedUnchangedDocumentDiagnosticReport]", t) +} + +func (t *Or_DocumentDiagnosticReport) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 RelatedFullDocumentDiagnosticReport + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 RelatedUnchangedDocumentDiagnosticReport + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [RelatedFullDocumentDiagnosticReport RelatedUnchangedDocumentDiagnosticReport]"} +} + +// from line 3822 +func (t Or_DocumentDiagnosticReportPartialResult_relatedDocuments_Value) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FullDocumentDiagnosticReport: + return json.Marshal(x) + case UnchangedDocumentDiagnosticReport: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]", t) +} + +func (t *Or_DocumentDiagnosticReportPartialResult_relatedDocuments_Value) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FullDocumentDiagnosticReport + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 UnchangedDocumentDiagnosticReport + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]"} +} + +// from line 14095 +func (t Or_DocumentFilter) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case NotebookCellTextDocumentFilter: + return json.Marshal(x) + case TextDocumentFilter: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [NotebookCellTextDocumentFilter TextDocumentFilter]", t) +} + +func (t *Or_DocumentFilter) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 NotebookCellTextDocumentFilter + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 TextDocumentFilter + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [NotebookCellTextDocumentFilter TextDocumentFilter]"} +} + +// from line 4891 +func (t Or_Hover_contents) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case MarkedString: + return json.Marshal(x) + case MarkupContent: + return json.Marshal(x) + case []MarkedString: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [MarkedString MarkupContent []MarkedString]", t) +} + +func (t *Or_Hover_contents) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 MarkedString + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 MarkupContent + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 []MarkedString + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [MarkedString MarkupContent []MarkedString]"} +} + +// from line 3658 +func (t Or_InlayHint_label) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case []InlayHintLabelPart: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [[]InlayHintLabelPart string]", t) +} + +func (t *Or_InlayHint_label) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 []InlayHintLabelPart + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [[]InlayHintLabelPart string]"} +} + +// from line 13863 +func (t Or_InlineValue) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case InlineValueEvaluatableExpression: + return json.Marshal(x) + case InlineValueText: + return json.Marshal(x) + case InlineValueVariableLookup: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [InlineValueEvaluatableExpression InlineValueText InlineValueVariableLookup]", t) +} + +func (t *Or_InlineValue) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 InlineValueEvaluatableExpression + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 InlineValueText + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 InlineValueVariableLookup + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [InlineValueEvaluatableExpression InlineValueText InlineValueVariableLookup]"} +} + +// from line 14060 +func (t Or_MarkedString) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case Msg_MarkedString: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [Msg_MarkedString string]", t) +} + +func (t *Or_MarkedString) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 Msg_MarkedString + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [Msg_MarkedString string]"} +} + +// from line 10118 +func (t Or_NotebookCellTextDocumentFilter_notebook) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case NotebookDocumentFilter: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilter string]", t) +} + +func (t *Or_NotebookCellTextDocumentFilter_notebook) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 NotebookDocumentFilter + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilter string]"} +} + +// from line 9857 +func (t Or_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_notebook) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case NotebookDocumentFilter: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilter string]", t) +} + +func (t *Or_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_notebook) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 NotebookDocumentFilter + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilter string]"} +} + +// from line 7168 +func (t Or_RelatedFullDocumentDiagnosticReport_relatedDocuments_Value) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FullDocumentDiagnosticReport: + return json.Marshal(x) + case UnchangedDocumentDiagnosticReport: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]", t) +} + +func (t *Or_RelatedFullDocumentDiagnosticReport_relatedDocuments_Value) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FullDocumentDiagnosticReport + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 UnchangedDocumentDiagnosticReport + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]"} +} + +// from line 7207 +func (t Or_RelatedUnchangedDocumentDiagnosticReport_relatedDocuments_Value) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FullDocumentDiagnosticReport: + return json.Marshal(x) + case UnchangedDocumentDiagnosticReport: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]", t) +} + +func (t *Or_RelatedUnchangedDocumentDiagnosticReport_relatedDocuments_Value) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FullDocumentDiagnosticReport + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 UnchangedDocumentDiagnosticReport + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]"} +} + +// from line 10741 +func (t Or_RelativePattern_baseUri) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case URI: + return json.Marshal(x) + case WorkspaceFolder: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [URI WorkspaceFolder]", t) +} + +func (t *Or_RelativePattern_baseUri) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 URI + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 WorkspaceFolder + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [URI WorkspaceFolder]"} +} + +// from line 1371 +func (t Or_Result_textDocument_codeAction_Item0_Elem) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case CodeAction: + return json.Marshal(x) + case Command: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [CodeAction Command]", t) +} + +func (t *Or_Result_textDocument_codeAction_Item0_Elem) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 CodeAction + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 Command + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [CodeAction Command]"} +} + +// from line 12197 +func (t Or_SemanticTokensClientCapabilities_requests_full) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FFullPRequests: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FFullPRequests bool]", t) +} + +func (t *Or_SemanticTokensClientCapabilities_requests_full) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FFullPRequests + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FFullPRequests bool]"} +} + +// from line 12177 +func (t Or_SemanticTokensClientCapabilities_requests_range) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FRangePRequests: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FRangePRequests bool]", t) +} + +func (t *Or_SemanticTokensClientCapabilities_requests_range) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FRangePRequests + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FRangePRequests bool]"} +} + +// from line 6579 +func (t Or_SemanticTokensOptions_full) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case PFullESemanticTokensOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [PFullESemanticTokensOptions bool]", t) +} + +func (t *Or_SemanticTokensOptions_full) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 PFullESemanticTokensOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [PFullESemanticTokensOptions bool]"} +} + +// from line 6559 +func (t Or_SemanticTokensOptions_range) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case PRangeESemanticTokensOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [PRangeESemanticTokensOptions bool]", t) +} + +func (t *Or_SemanticTokensOptions_range) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 PRangeESemanticTokensOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [PRangeESemanticTokensOptions bool]"} +} + +// from line 8227 +func (t Or_ServerCapabilities_callHierarchyProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case CallHierarchyOptions: + return json.Marshal(x) + case CallHierarchyRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [CallHierarchyOptions CallHierarchyRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_callHierarchyProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 CallHierarchyOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 CallHierarchyRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [CallHierarchyOptions CallHierarchyRegistrationOptions bool]"} +} + +// from line 8035 +func (t Or_ServerCapabilities_codeActionProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case CodeActionOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [CodeActionOptions bool]", t) +} + +func (t *Or_ServerCapabilities_codeActionProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 CodeActionOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [CodeActionOptions bool]"} +} + +// from line 8071 +func (t Or_ServerCapabilities_colorProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DocumentColorOptions: + return json.Marshal(x) + case DocumentColorRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DocumentColorOptions DocumentColorRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_colorProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DocumentColorOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 DocumentColorRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DocumentColorOptions DocumentColorRegistrationOptions bool]"} +} + +// from line 7897 +func (t Or_ServerCapabilities_declarationProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DeclarationOptions: + return json.Marshal(x) + case DeclarationRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DeclarationOptions DeclarationRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_declarationProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DeclarationOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 DeclarationRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DeclarationOptions DeclarationRegistrationOptions bool]"} +} + +// from line 7919 +func (t Or_ServerCapabilities_definitionProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DefinitionOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DefinitionOptions bool]", t) +} + +func (t *Or_ServerCapabilities_definitionProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DefinitionOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DefinitionOptions bool]"} +} + +// from line 8384 +func (t Or_ServerCapabilities_diagnosticProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DiagnosticOptions: + return json.Marshal(x) + case DiagnosticRegistrationOptions: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DiagnosticOptions DiagnosticRegistrationOptions]", t) +} + +func (t *Or_ServerCapabilities_diagnosticProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DiagnosticOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 DiagnosticRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DiagnosticOptions DiagnosticRegistrationOptions]"} +} + +// from line 8111 +func (t Or_ServerCapabilities_documentFormattingProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DocumentFormattingOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DocumentFormattingOptions bool]", t) +} + +func (t *Or_ServerCapabilities_documentFormattingProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DocumentFormattingOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DocumentFormattingOptions bool]"} +} + +// from line 7999 +func (t Or_ServerCapabilities_documentHighlightProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DocumentHighlightOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DocumentHighlightOptions bool]", t) +} + +func (t *Or_ServerCapabilities_documentHighlightProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DocumentHighlightOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DocumentHighlightOptions bool]"} +} + +// from line 8129 +func (t Or_ServerCapabilities_documentRangeFormattingProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DocumentRangeFormattingOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DocumentRangeFormattingOptions bool]", t) +} + +func (t *Or_ServerCapabilities_documentRangeFormattingProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DocumentRangeFormattingOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DocumentRangeFormattingOptions bool]"} +} + +// from line 8017 +func (t Or_ServerCapabilities_documentSymbolProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case DocumentSymbolOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [DocumentSymbolOptions bool]", t) +} + +func (t *Or_ServerCapabilities_documentSymbolProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 DocumentSymbolOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [DocumentSymbolOptions bool]"} +} + +// from line 8174 +func (t Or_ServerCapabilities_foldingRangeProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case FoldingRangeOptions: + return json.Marshal(x) + case FoldingRangeRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [FoldingRangeOptions FoldingRangeRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_foldingRangeProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 FoldingRangeOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 FoldingRangeRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [FoldingRangeOptions FoldingRangeRegistrationOptions bool]"} +} + +// from line 7870 +func (t Or_ServerCapabilities_hoverProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case HoverOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [HoverOptions bool]", t) +} + +func (t *Or_ServerCapabilities_hoverProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 HoverOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [HoverOptions bool]"} +} + +// from line 7959 +func (t Or_ServerCapabilities_implementationProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case ImplementationOptions: + return json.Marshal(x) + case ImplementationRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [ImplementationOptions ImplementationRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_implementationProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 ImplementationOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 ImplementationRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [ImplementationOptions ImplementationRegistrationOptions bool]"} +} + +// from line 8361 +func (t Or_ServerCapabilities_inlayHintProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case InlayHintOptions: + return json.Marshal(x) + case InlayHintRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [InlayHintOptions InlayHintRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_inlayHintProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 InlayHintOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 InlayHintRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [InlayHintOptions InlayHintRegistrationOptions bool]"} +} + +// from line 8338 +func (t Or_ServerCapabilities_inlineValueProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case InlineValueOptions: + return json.Marshal(x) + case InlineValueRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [InlineValueOptions InlineValueRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_inlineValueProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 InlineValueOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 InlineValueRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [InlineValueOptions InlineValueRegistrationOptions bool]"} +} + +// from line 8250 +func (t Or_ServerCapabilities_linkedEditingRangeProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case LinkedEditingRangeOptions: + return json.Marshal(x) + case LinkedEditingRangeRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [LinkedEditingRangeOptions LinkedEditingRangeRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_linkedEditingRangeProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 LinkedEditingRangeOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 LinkedEditingRangeRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [LinkedEditingRangeOptions LinkedEditingRangeRegistrationOptions bool]"} +} + +// from line 8292 +func (t Or_ServerCapabilities_monikerProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case MonikerOptions: + return json.Marshal(x) + case MonikerRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [MonikerOptions MonikerRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_monikerProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 MonikerOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 MonikerRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [MonikerOptions MonikerRegistrationOptions bool]"} +} + +// from line 7842 +func (t Or_ServerCapabilities_notebookDocumentSync) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case NotebookDocumentSyncOptions: + return json.Marshal(x) + case NotebookDocumentSyncRegistrationOptions: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [NotebookDocumentSyncOptions NotebookDocumentSyncRegistrationOptions]", t) +} + +func (t *Or_ServerCapabilities_notebookDocumentSync) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 NotebookDocumentSyncOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 NotebookDocumentSyncRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentSyncOptions NotebookDocumentSyncRegistrationOptions]"} +} + +// from line 7981 +func (t Or_ServerCapabilities_referencesProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case ReferenceOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [ReferenceOptions bool]", t) +} + +func (t *Or_ServerCapabilities_referencesProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 ReferenceOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [ReferenceOptions bool]"} +} + +// from line 8156 +func (t Or_ServerCapabilities_renameProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case RenameOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [RenameOptions bool]", t) +} + +func (t *Or_ServerCapabilities_renameProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 RenameOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [RenameOptions bool]"} +} + +// from line 8196 +func (t Or_ServerCapabilities_selectionRangeProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case SelectionRangeOptions: + return json.Marshal(x) + case SelectionRangeRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [SelectionRangeOptions SelectionRangeRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_selectionRangeProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 SelectionRangeOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 SelectionRangeRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [SelectionRangeOptions SelectionRangeRegistrationOptions bool]"} +} + +// from line 8273 +func (t Or_ServerCapabilities_semanticTokensProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case SemanticTokensOptions: + return json.Marshal(x) + case SemanticTokensRegistrationOptions: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [SemanticTokensOptions SemanticTokensRegistrationOptions]", t) +} + +func (t *Or_ServerCapabilities_semanticTokensProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 SemanticTokensOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 SemanticTokensRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [SemanticTokensOptions SemanticTokensRegistrationOptions]"} +} + +// from line 7824 +func (t Or_ServerCapabilities_textDocumentSync) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case TextDocumentSyncKind: + return json.Marshal(x) + case TextDocumentSyncOptions: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [TextDocumentSyncKind TextDocumentSyncOptions]", t) +} + +func (t *Or_ServerCapabilities_textDocumentSync) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 TextDocumentSyncKind + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 TextDocumentSyncOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [TextDocumentSyncKind TextDocumentSyncOptions]"} +} + +// from line 7937 +func (t Or_ServerCapabilities_typeDefinitionProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case TypeDefinitionOptions: + return json.Marshal(x) + case TypeDefinitionRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [TypeDefinitionOptions TypeDefinitionRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_typeDefinitionProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 TypeDefinitionOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 TypeDefinitionRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [TypeDefinitionOptions TypeDefinitionRegistrationOptions bool]"} +} + +// from line 8315 +func (t Or_ServerCapabilities_typeHierarchyProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case TypeHierarchyOptions: + return json.Marshal(x) + case TypeHierarchyRegistrationOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [TypeHierarchyOptions TypeHierarchyRegistrationOptions bool]", t) +} + +func (t *Or_ServerCapabilities_typeHierarchyProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 TypeHierarchyOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 TypeHierarchyRegistrationOptions + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 bool + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [TypeHierarchyOptions TypeHierarchyRegistrationOptions bool]"} +} + +// from line 8093 +func (t Or_ServerCapabilities_workspaceSymbolProvider) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case WorkspaceSymbolOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [WorkspaceSymbolOptions bool]", t) +} + +func (t *Or_ServerCapabilities_workspaceSymbolProvider) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 WorkspaceSymbolOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [WorkspaceSymbolOptions bool]"} +} + +// from line 8841 +func (t Or_SignatureInformation_documentation) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case MarkupContent: + return json.Marshal(x) + case string: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t) +} + +func (t *Or_SignatureInformation_documentation) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 MarkupContent + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 string + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"} +} + +// from line 6692 +func (t Or_TextDocumentEdit_edits_Elem) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case AnnotatedTextEdit: + return json.Marshal(x) + case TextEdit: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [AnnotatedTextEdit TextEdit]", t) +} + +func (t *Or_TextDocumentEdit_edits_Elem) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 AnnotatedTextEdit + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 TextEdit + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [AnnotatedTextEdit TextEdit]"} +} + +// from line 9777 +func (t Or_TextDocumentSyncOptions_save) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case SaveOptions: + return json.Marshal(x) + case bool: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [SaveOptions bool]", t) +} + +func (t *Or_TextDocumentSyncOptions_save) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 SaveOptions + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 bool + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [SaveOptions bool]"} +} + +// from line 13986 +func (t Or_WorkspaceDocumentDiagnosticReport) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case WorkspaceFullDocumentDiagnosticReport: + return json.Marshal(x) + case WorkspaceUnchangedDocumentDiagnosticReport: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [WorkspaceFullDocumentDiagnosticReport WorkspaceUnchangedDocumentDiagnosticReport]", t) +} + +func (t *Or_WorkspaceDocumentDiagnosticReport) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 WorkspaceFullDocumentDiagnosticReport + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 WorkspaceUnchangedDocumentDiagnosticReport + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [WorkspaceFullDocumentDiagnosticReport WorkspaceUnchangedDocumentDiagnosticReport]"} +} + +// from line 3219 +func (t Or_WorkspaceEdit_documentChanges_Elem) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case CreateFile: + return json.Marshal(x) + case DeleteFile: + return json.Marshal(x) + case RenameFile: + return json.Marshal(x) + case TextDocumentEdit: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [CreateFile DeleteFile RenameFile TextDocumentEdit]", t) +} + +func (t *Or_WorkspaceEdit_documentChanges_Elem) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 CreateFile + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 DeleteFile + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + var h2 RenameFile + if err := json.Unmarshal(x, &h2); err == nil { + t.Value = h2 + return nil + } + var h3 TextDocumentEdit + if err := json.Unmarshal(x, &h3); err == nil { + t.Value = h3 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [CreateFile DeleteFile RenameFile TextDocumentEdit]"} +} + +// from line 248 +func (t Or_textDocument_declaration) MarshalJSON() ([]byte, error) { + switch x := t.Value.(type) { + case Declaration: + return json.Marshal(x) + case []DeclarationLink: + return json.Marshal(x) + case nil: + return []byte("null"), nil + } + return nil, fmt.Errorf("type %T not one of [Declaration []DeclarationLink]", t) +} + +func (t *Or_textDocument_declaration) UnmarshalJSON(x []byte) error { + if string(x) == "null" { + t.Value = nil + return nil + } + var h0 Declaration + if err := json.Unmarshal(x, &h0); err == nil { + t.Value = h0 + return nil + } + var h1 []DeclarationLink + if err := json.Unmarshal(x, &h1); err == nil { + t.Value = h1 + return nil + } + return &UnmarshalError{"unmarshal failed to match one of [Declaration []DeclarationLink]"} +} diff --git a/gopls/internal/lsp/protocol/tsprotocol.go b/gopls/internal/lsp/protocol/tsprotocol.go new file mode 100644 index 000000000..e639a57ab --- /dev/null +++ b/gopls/internal/lsp/protocol/tsprotocol.go @@ -0,0 +1,5450 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated for LSP. DO NOT EDIT. + +package protocol + +// Code generated from protocol/metaModel.json at ref release/protocol/3.17.3-next.6 (hash 56c23c557e3568a9f56f42435fd5a80f9458957f). +// https://github.com/microsoft/vscode-languageserver-node/blob/release/protocol/3.17.3-next.6/protocol/metaModel.json +// LSP metaData.version = 3.17.0. + +import "encoding/json" + +// A special text edit with an additional change annotation. +// +// @since 3.16.0. +type AnnotatedTextEdit struct { // line 9372 + // The actual identifier of the change annotation + AnnotationID ChangeAnnotationIdentifier `json:"annotationId"` + TextEdit +} + +// The parameters passed via a apply workspace edit request. +type ApplyWorkspaceEditParams struct { // line 5984 + // An optional label of the workspace edit. This label is + // presented in the user interface for example on an undo + // stack to undo the workspace edit. + Label string `json:"label,omitempty"` + // The edits to apply. + Edit WorkspaceEdit `json:"edit"` +} + +// The result returned from the apply workspace edit request. +// +// @since 3.17 renamed from ApplyWorkspaceEditResponse +type ApplyWorkspaceEditResult struct { // line 6007 + // Indicates whether the edit was applied or not. + Applied bool `json:"applied"` + // An optional textual description for why the edit was not applied. + // This may be used by the server for diagnostic logging or to provide + // a suitable error for a request that triggered the edit. + FailureReason string `json:"failureReason,omitempty"` + // Depending on the client's failure handling strategy `failedChange` might + // contain the index of the change that failed. This property is only available + // if the client signals a `failureHandlingStrategy` in its client capabilities. + FailedChange uint32 `json:"failedChange,omitempty"` +} + +// A base for all symbol information. +type BaseSymbolInformation struct { // line 8966 + // The name of this symbol. + Name string `json:"name"` + // The kind of this symbol. + Kind SymbolKind `json:"kind"` + // Tags for this symbol. + // + // @since 3.16.0 + Tags []SymbolTag `json:"tags,omitempty"` + // The name of the symbol containing this symbol. This information is for + // user interface purposes (e.g. to render a qualifier in the user interface + // if necessary). It can't be used to re-infer a hierarchy for the document + // symbols. + ContainerName string `json:"containerName,omitempty"` +} + +// @since 3.16.0 +type CallHierarchyClientCapabilities struct { // line 12141 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + // return value for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// Represents an incoming call, e.g. a caller of a method or constructor. +// +// @since 3.16.0 +type CallHierarchyIncomingCall struct { // line 2779 + // The item that makes the call. + From CallHierarchyItem `json:"from"` + // The ranges at which the calls appear. This is relative to the caller + // denoted by {@link CallHierarchyIncomingCall.from `this.from`}. + FromRanges []Range `json:"fromRanges"` +} + +// The parameter of a `callHierarchy/incomingCalls` request. +// +// @since 3.16.0 +type CallHierarchyIncomingCallsParams struct { // line 2755 + Item CallHierarchyItem `json:"item"` + WorkDoneProgressParams + PartialResultParams +} + +// Represents programming constructs like functions or constructors in the context +// of call hierarchy. +// +// @since 3.16.0 +type CallHierarchyItem struct { // line 2656 + // The name of this item. + Name string `json:"name"` + // The kind of this item. + Kind SymbolKind `json:"kind"` + // Tags for this item. + Tags []SymbolTag `json:"tags,omitempty"` + // More detail for this item, e.g. the signature of a function. + Detail string `json:"detail,omitempty"` + // The resource identifier of this item. + URI DocumentURI `json:"uri"` + // The range enclosing this symbol not including leading/trailing whitespace but everything else, e.g. comments and code. + Range Range `json:"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 {@link CallHierarchyItem.range `range`}. + SelectionRange Range `json:"selectionRange"` + // A data entry field that is preserved between a call hierarchy prepare and + // incoming calls or outgoing calls requests. + Data interface{} `json:"data,omitempty"` +} + +// Call hierarchy options used during static registration. +// +// @since 3.16.0 +type CallHierarchyOptions struct { // line 6534 + WorkDoneProgressOptions +} + +// Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc. +// +// @since 3.16.0 +type CallHierarchyOutgoingCall struct { // line 2829 + // The item that is called. + To CallHierarchyItem `json:"to"` + // The range at which this item is called. This is the range relative to the caller, e.g the item + // passed to {@link CallHierarchyItemProvider.provideCallHierarchyOutgoingCalls `provideCallHierarchyOutgoingCalls`} + // and not {@link CallHierarchyOutgoingCall.to `this.to`}. + FromRanges []Range `json:"fromRanges"` +} + +// The parameter of a `callHierarchy/outgoingCalls` request. +// +// @since 3.16.0 +type CallHierarchyOutgoingCallsParams struct { // line 2805 + Item CallHierarchyItem `json:"item"` + WorkDoneProgressParams + PartialResultParams +} + +// The parameter of a `textDocument/prepareCallHierarchy` request. +// +// @since 3.16.0 +type CallHierarchyPrepareParams struct { // line 2638 + TextDocumentPositionParams + WorkDoneProgressParams +} + +// Call hierarchy options used during static or dynamic registration. +// +// @since 3.16.0 +type CallHierarchyRegistrationOptions struct { // line 2733 + TextDocumentRegistrationOptions + CallHierarchyOptions + StaticRegistrationOptions +} +type CancelParams struct { // line 6179 + // The request id to cancel. + ID interface{} `json:"id"` +} + +// Additional information that describes document changes. +// +// @since 3.16.0 +type ChangeAnnotation struct { // line 6831 + // A human-readable string describing the actual change. The string + // is rendered prominent in the user interface. + Label string `json:"label"` + // A flag which indicates that user confirmation is needed + // before applying the change. + NeedsConfirmation bool `json:"needsConfirmation,omitempty"` + // A human-readable string which is rendered less prominent in + // the user interface. + Description string `json:"description,omitempty"` +} + +// An identifier to refer to a change annotation stored with a workspace edit. +type ChangeAnnotationIdentifier = string // (alias) line 13976 +// Defines the capabilities provided by the client. +type ClientCapabilities struct { // line 9674 + // Workspace specific client capabilities. + Workspace WorkspaceClientCapabilities `json:"workspace,omitempty"` + // Text document specific client capabilities. + TextDocument TextDocumentClientCapabilities `json:"textDocument,omitempty"` + // Capabilities specific to the notebook document support. + // + // @since 3.17.0 + NotebookDocument *NotebookDocumentClientCapabilities `json:"notebookDocument,omitempty"` + // Window specific client capabilities. + Window WindowClientCapabilities `json:"window,omitempty"` + // General client capabilities. + // + // @since 3.16.0 + General *GeneralClientCapabilities `json:"general,omitempty"` + // Experimental client capabilities. + Experimental interface{} `json:"experimental,omitempty"` +} + +// A code action represents a change that can be performed in code, e.g. to fix a problem or +// to refactor code. +// +// A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed. +type CodeAction struct { // line 5382 + // A short, human-readable, title for this code action. + Title string `json:"title"` + // The kind of the code action. + // + // Used to filter code actions. + Kind CodeActionKind `json:"kind,omitempty"` + // The diagnostics that this code action resolves. + Diagnostics []Diagnostic `json:"diagnostics,omitempty"` + // Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted + // by keybindings. + // + // A quick fix should be marked preferred if it properly addresses the underlying error. + // A refactoring should be marked preferred if it is the most reasonable choice of actions to take. + // + // @since 3.15.0 + IsPreferred bool `json:"isPreferred,omitempty"` + // Marks that the code action cannot currently be applied. + // + // Clients should follow the following guidelines regarding disabled code actions: + // + // - Disabled code actions are not shown in automatic [lightbulbs](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) + // code action menus. + // + // - Disabled actions are shown as faded out in the code action menu when the user requests a more specific type + // of code action, such as refactorings. + // + // - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions) + // that auto applies a code action and only disabled code actions are returned, the client should show the user an + // error message with `reason` in the editor. + // + // @since 3.16.0 + Disabled *PDisabledMsg_textDocument_codeAction `json:"disabled,omitempty"` + // The workspace edit this code action performs. + Edit *WorkspaceEdit `json:"edit,omitempty"` + // A command this code action executes. If a code action + // provides an edit and a command, first the edit is + // executed and then the command. + Command *Command `json:"command,omitempty"` + // A data entry field that is preserved on a code action between + // a `textDocument/codeAction` and a `codeAction/resolve` request. + // + // @since 3.16.0 + Data interface{} `json:"data,omitempty"` +} + +// The Client Capabilities of a {@link CodeActionRequest}. +type CodeActionClientCapabilities struct { // line 11721 + // Whether code action supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client support code action literals of type `CodeAction` as a valid + // response of the `textDocument/codeAction` request. If the property is not + // set the request can only return `Command` literals. + // + // @since 3.8.0 + CodeActionLiteralSupport PCodeActionLiteralSupportPCodeAction `json:"codeActionLiteralSupport,omitempty"` + // Whether code action supports the `isPreferred` property. + // + // @since 3.15.0 + IsPreferredSupport bool `json:"isPreferredSupport,omitempty"` + // Whether code action supports the `disabled` property. + // + // @since 3.16.0 + DisabledSupport bool `json:"disabledSupport,omitempty"` + // Whether code action supports the `data` property which is + // preserved between a `textDocument/codeAction` and a + // `codeAction/resolve` request. + // + // @since 3.16.0 + DataSupport bool `json:"dataSupport,omitempty"` + // Whether the client supports resolving additional code action + // properties via a separate `codeAction/resolve` request. + // + // @since 3.16.0 + ResolveSupport *PResolveSupportPCodeAction `json:"resolveSupport,omitempty"` + // Whether the client honors the change annotations in + // text edits and resource operations returned via the + // `CodeAction#edit` property by for example presenting + // the workspace edit in the user interface and asking + // for confirmation. + // + // @since 3.16.0 + HonorsChangeAnnotations bool `json:"honorsChangeAnnotations,omitempty"` +} + +// Contains additional diagnostic information about the context in which +// a {@link CodeActionProvider.provideCodeActions code action} is run. +type CodeActionContext struct { // line 9032 + // An array of diagnostics known on the client side overlapping the range provided to the + // `textDocument/codeAction` request. They are provided so that the server knows which + // errors are currently presented to the user for the given range. There is no guarantee + // that these accurately reflect the error state of the resource. The primary parameter + // to compute code actions is the provided range. + Diagnostics []Diagnostic `json:"diagnostics"` + // Requested kind of actions to return. + // + // Actions not of this kind are filtered out by the client before being shown. So servers + // can omit computing them. + Only []CodeActionKind `json:"only,omitempty"` + // The reason why code actions were requested. + // + // @since 3.17.0 + TriggerKind *CodeActionTriggerKind `json:"triggerKind,omitempty"` +} + +// A set of predefined code action kinds +type CodeActionKind string // line 13326 +// Provider options for a {@link CodeActionRequest}. +type CodeActionOptions struct { // line 9071 + // CodeActionKinds that this server may return. + // + // The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server + // may list out every specific kind they provide. + CodeActionKinds []CodeActionKind `json:"codeActionKinds,omitempty"` + // The server provides support to resolve additional + // information for a code action. + // + // @since 3.16.0 + ResolveProvider bool `json:"resolveProvider,omitempty"` + WorkDoneProgressOptions +} + +// The parameters of a {@link CodeActionRequest}. +type CodeActionParams struct { // line 5308 + // The document in which the command was invoked. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The range for which the command was invoked. + Range Range `json:"range"` + // Context carrying additional information. + Context CodeActionContext `json:"context"` + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link CodeActionRequest}. +type CodeActionRegistrationOptions struct { // line 5476 + TextDocumentRegistrationOptions + CodeActionOptions +} + +// The reason why code actions were requested. +// +// @since 3.17.0 +type CodeActionTriggerKind uint32 // line 13606 +// Structure to capture a description for an error code. +// +// @since 3.16.0 +type CodeDescription struct { // line 10026 + // An URI to open with more information about the diagnostic error. + Href URI `json:"href"` +} + +// A code lens represents a {@link Command command} that should be shown along with +// source text, like the number of references, a way to run tests, etc. +// +// A code lens is _unresolved_ when no command is associated to it. For performance +// reasons the creation of a code lens and resolving should be done in two stages. +type CodeLens struct { // line 5599 + // The range in which this code lens is valid. Should only span a single line. + Range Range `json:"range"` + // The command this code lens represents. + Command *Command `json:"command,omitempty"` + // A data entry field that is preserved on a code lens item between + // a {@link CodeLensRequest} and a [CodeLensResolveRequest] + // (#CodeLensResolveRequest) + Data interface{} `json:"data,omitempty"` +} + +// The client capabilities of a {@link CodeLensRequest}. +type CodeLensClientCapabilities struct { // line 11835 + // Whether code lens supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// Code Lens provider options of a {@link CodeLensRequest}. +type CodeLensOptions struct { // line 9127 + // Code lens has a resolve provider as well. + ResolveProvider bool `json:"resolveProvider,omitempty"` + WorkDoneProgressOptions +} + +// The parameters of a {@link CodeLensRequest}. +type CodeLensParams struct { // line 5575 + // The document to request code lens for. + TextDocument TextDocumentIdentifier `json:"textDocument"` + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link CodeLensRequest}. +type CodeLensRegistrationOptions struct { // line 5631 + TextDocumentRegistrationOptions + CodeLensOptions +} + +// @since 3.16.0 +type CodeLensWorkspaceClientCapabilities struct { // line 10993 + // 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 + // code lenses currently shown. It should be used with absolute care and is + // useful for situation where a server for example detect a project wide + // change that requires such a calculation. + RefreshSupport bool `json:"refreshSupport,omitempty"` +} + +// Represents a color in RGBA space. +type Color struct { // line 6433 + // The red component of this color in the range [0-1]. + Red float64 `json:"red"` + // The green component of this color in the range [0-1]. + Green float64 `json:"green"` + // The blue component of this color in the range [0-1]. + Blue float64 `json:"blue"` + // The alpha component of this color in the range [0-1]. + Alpha float64 `json:"alpha"` +} + +// Represents a color range from a document. +type ColorInformation struct { // line 2239 + // The range in the document where this color appears. + Range Range `json:"range"` + // The actual color value for this color range. + Color Color `json:"color"` +} +type ColorPresentation struct { // line 2321 + // The label of this color presentation. It will be shown on the color + // picker header. By default this is also the text that is inserted when selecting + // this color presentation. + Label string `json:"label"` + // An {@link TextEdit edit} which is applied to a document when selecting + // this presentation for the color. When `falsy` the {@link ColorPresentation.label label} + // is used. + TextEdit *TextEdit `json:"textEdit,omitempty"` + // An optional array of additional {@link TextEdit text edits} that are applied when + // selecting this color presentation. Edits must not overlap with the main {@link ColorPresentation.textEdit edit} nor with themselves. + AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"` +} + +// Parameters for a {@link ColorPresentationRequest}. +type ColorPresentationParams struct { // line 2281 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The color to request presentations for. + Color Color `json:"color"` + // The range where the color would be inserted. Serves as a context. + Range Range `json:"range"` + WorkDoneProgressParams + PartialResultParams +} + +// Represents a reference to a command. Provides a title which +// will be used to represent a command in the UI and, optionally, +// an array of arguments which will be passed to the command handler +// function when invoked. +type Command struct { // line 5348 + // Title of the command, like `save`. + Title string `json:"title"` + // The identifier of the actual command handler. + Command string `json:"command"` + // Arguments that the command handler should be + // invoked with. + Arguments []json.RawMessage `json:"arguments,omitempty"` +} + +// Completion client capabilities +type CompletionClientCapabilities struct { // line 11168 + // Whether completion supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports the following `CompletionItem` specific + // capabilities. + CompletionItem PCompletionItemPCompletion `json:"completionItem,omitempty"` + CompletionItemKind *PCompletionItemKindPCompletion `json:"completionItemKind,omitempty"` + // Defines how the client handles whitespace and indentation + // when accepting a completion item that uses multi line + // text in either `insertText` or `textEdit`. + // + // @since 3.17.0 + InsertTextMode InsertTextMode `json:"insertTextMode,omitempty"` + // The client supports to send additional context information for a + // `textDocument/completion` request. + ContextSupport bool `json:"contextSupport,omitempty"` + // The client supports the following `CompletionList` specific + // capabilities. + // + // @since 3.17.0 + CompletionList *PCompletionListPCompletion `json:"completionList,omitempty"` +} + +// Contains additional information about the context in which a completion request is triggered. +type CompletionContext struct { // line 8628 + // How the completion was triggered. + TriggerKind CompletionTriggerKind `json:"triggerKind"` + // The trigger character (a single character) that has trigger code complete. + // Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter` + TriggerCharacter string `json:"triggerCharacter,omitempty"` +} + +// A completion item represents a text snippet that is +// proposed to complete text that is being typed. +type CompletionItem struct { // line 4528 + // The label of this completion item. + // + // The label property is also by default the text that + // is inserted when selecting this completion. + // + // If label details are provided the label itself should + // be an unqualified name of the completion item. + Label string `json:"label"` + // Additional details for the label + // + // @since 3.17.0 + LabelDetails *CompletionItemLabelDetails `json:"labelDetails,omitempty"` + // The kind of this completion item. Based of the kind + // an icon is chosen by the editor. + Kind CompletionItemKind `json:"kind,omitempty"` + // Tags for this completion item. + // + // @since 3.15.0 + Tags []CompletionItemTag `json:"tags,omitempty"` + // A human-readable string with additional information + // about this item, like type or symbol information. + Detail string `json:"detail,omitempty"` + // A human-readable string that represents a doc-comment. + Documentation *Or_CompletionItem_documentation `json:"documentation,omitempty"` + // Indicates if this item is deprecated. + // @deprecated Use `tags` instead. + Deprecated bool `json:"deprecated,omitempty"` + // Select this item when showing. + // + // *Note* that only one completion item can be selected and that the + // tool / client decides which item that is. The rule is that the *first* + // item of those that match best is selected. + Preselect bool `json:"preselect,omitempty"` + // A string that should be used when comparing this item + // with other items. When `falsy` the {@link CompletionItem.label label} + // is used. + SortText string `json:"sortText,omitempty"` + // A string that should be used when filtering a set of + // completion items. When `falsy` the {@link CompletionItem.label label} + // is used. + FilterText string `json:"filterText,omitempty"` + // A string that should be inserted into a document when selecting + // this completion. When `falsy` the {@link CompletionItem.label label} + // is used. + // + // The `insertText` is subject to interpretation by the client side. + // Some tools might not take the string literally. For example + // VS Code when code complete is requested in this example + // `con<cursor position>` and a completion item with an `insertText` of + // `console` is provided it will only insert `sole`. Therefore it is + // recommended to use `textEdit` instead since it avoids additional client + // side interpretation. + InsertText string `json:"insertText,omitempty"` + // The format of the insert text. The format applies to both the + // `insertText` property and the `newText` property of a provided + // `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`. + // + // Please note that the insertTextFormat doesn't apply to + // `additionalTextEdits`. + InsertTextFormat *InsertTextFormat `json:"insertTextFormat,omitempty"` + // How whitespace and indentation is handled during completion + // item insertion. If not provided the clients default value depends on + // the `textDocument.completion.insertTextMode` client capability. + // + // @since 3.16.0 + InsertTextMode *InsertTextMode `json:"insertTextMode,omitempty"` + // An {@link TextEdit edit} which is applied to a document when selecting + // this completion. When an edit is provided the value of + // {@link CompletionItem.insertText insertText} is ignored. + // + // Most editors support two different operations when accepting a completion + // item. One is to insert a completion text and the other is to replace an + // existing text with a completion text. Since this can usually not be + // predetermined by a server it can report both ranges. Clients need to + // signal support for `InsertReplaceEdits` via the + // `textDocument.completion.insertReplaceSupport` client capability + // property. + // + // *Note 1:* The text edit's range as well as both ranges from an insert + // replace edit must be a [single line] and they must contain the position + // at which completion has been requested. + // *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range + // must be a prefix of the edit's replace range, that means it must be + // contained and starting at the same position. + // + // @since 3.16.0 additional type `InsertReplaceEdit` + TextEdit *TextEdit `json:"textEdit,omitempty"` + // The edit text used if the completion item is part of a CompletionList and + // CompletionList defines an item default for the text edit range. + // + // Clients will only honor this property if they opt into completion list + // item defaults using the capability `completionList.itemDefaults`. + // + // If not provided and a list's default range is provided the label + // property is used as a text. + // + // @since 3.17.0 + TextEditText string `json:"textEditText,omitempty"` + // An optional array of additional {@link TextEdit text edits} that are applied when + // selecting this completion. Edits must not overlap (including the same insert position) + // with the main {@link CompletionItem.textEdit edit} nor with themselves. + // + // Additional text edits should be used to change text unrelated to the current cursor position + // (for example adding an import statement at the top of the file if the completion item will + // insert an unqualified type). + AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"` + // An optional set of characters that when pressed while this completion is active will accept it first and + // then type that character. *Note* that all commit characters should have `length=1` and that superfluous + // characters will be ignored. + CommitCharacters []string `json:"commitCharacters,omitempty"` + // An optional {@link Command command} that is executed *after* inserting this completion. *Note* that + // additional modifications to the current document should be described with the + // {@link CompletionItem.additionalTextEdits additionalTextEdits}-property. + Command *Command `json:"command,omitempty"` + // A data entry field that is preserved on a completion item between a + // {@link CompletionRequest} and a {@link CompletionResolveRequest}. + Data interface{} `json:"data,omitempty"` +} + +// The kind of a completion entry. +type CompletionItemKind uint32 // line 13134 +// Additional details for a completion item label. +// +// @since 3.17.0 +type CompletionItemLabelDetails struct { // line 8651 + // An optional string which is rendered less prominently directly after {@link CompletionItem.label label}, + // without any spacing. Should be used for function signatures and type annotations. + Detail string `json:"detail,omitempty"` + // An optional string which is rendered less prominently after {@link CompletionItem.detail}. Should be used + // for fully qualified names and file paths. + Description string `json:"description,omitempty"` +} + +// Completion item tags are extra annotations that tweak the rendering of a completion +// item. +// +// @since 3.15.0 +type CompletionItemTag uint32 // line 13244 +// Represents a collection of {@link CompletionItem completion items} to be presented +// in the editor. +type CompletionList struct { // line 4737 + // This list it not complete. Further typing results in recomputing this list. + // + // Recomputed lists have all their items replaced (not appended) in the + // incomplete completion sessions. + IsIncomplete bool `json:"isIncomplete"` + // In many cases the items of an actual completion result share the same + // value for properties like `commitCharacters` or the range of a text + // edit. A completion list can therefore define item defaults which will + // be used if a completion item itself doesn't specify the value. + // + // If a completion list specifies a default value and a completion item + // also specifies a corresponding value the one from the item is used. + // + // Servers are only allowed to return default values if the client + // signals support for this via the `completionList.itemDefaults` + // capability. + // + // @since 3.17.0 + ItemDefaults *PItemDefaultsMsg_textDocument_completion `json:"itemDefaults,omitempty"` + // The completion items. + Items []CompletionItem `json:"items"` +} + +// Completion options. +type CompletionOptions struct { // line 8707 + // Most tools trigger completion request automatically without explicitly requesting + // it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user + // starts to type an identifier. For example if the user types `c` in a JavaScript file + // code complete will automatically pop up present `console` besides others as a + // completion item. Characters that make up identifiers don't need to be listed here. + // + // If code complete should automatically be trigger on characters not being valid inside + // an identifier (for example `.` in JavaScript) list them in `triggerCharacters`. + TriggerCharacters []string `json:"triggerCharacters,omitempty"` + // The list of all possible characters that commit a completion. This field can be used + // if clients don't support individual commit characters per completion item. See + // `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport` + // + // If a server provides both `allCommitCharacters` and commit characters on an individual + // completion item the ones on the completion item win. + // + // @since 3.2.0 + AllCommitCharacters []string `json:"allCommitCharacters,omitempty"` + // The server provides support to resolve additional + // information for a completion item. + ResolveProvider bool `json:"resolveProvider,omitempty"` + // The server supports the following `CompletionItem` specific + // capabilities. + // + // @since 3.17.0 + CompletionItem *PCompletionItemPCompletionProvider `json:"completionItem,omitempty"` + WorkDoneProgressOptions +} + +// Completion parameters +type CompletionParams struct { // line 4497 + // The completion context. This is only available it the client specifies + // to send this using the client capability `textDocument.completion.contextSupport === true` + Context CompletionContext `json:"context,omitempty"` + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link CompletionRequest}. +type CompletionRegistrationOptions struct { // line 4854 + TextDocumentRegistrationOptions + CompletionOptions +} + +// How a completion was triggered +type CompletionTriggerKind uint32 // line 13555 +type ConfigurationItem struct { // line 6396 + // The scope to get the configuration section for. + ScopeURI string `json:"scopeUri,omitempty"` + // The configuration section asked for. + Section string `json:"section,omitempty"` +} + +// The parameters of a configuration request. +type ConfigurationParams struct { // line 2199 + Items []ConfigurationItem `json:"items"` +} + +// Create file operation. +type CreateFile struct { // line 6712 + // A create + Kind string `json:"kind"` + // The resource to create. + URI DocumentURI `json:"uri"` + // Additional options + Options *CreateFileOptions `json:"options,omitempty"` + ResourceOperation +} + +// Options to create a file. +type CreateFileOptions struct { // line 9417 + // Overwrite existing file. Overwrite wins over `ignoreIfExists` + Overwrite bool `json:"overwrite,omitempty"` + // Ignore if exists. + IgnoreIfExists bool `json:"ignoreIfExists,omitempty"` +} + +// The parameters sent in notifications/requests for user-initiated creation of +// files. +// +// @since 3.16.0 +type CreateFilesParams struct { // line 3175 + // An array of all files/folders created in this operation. + Files []FileCreate `json:"files"` +} + +// The declaration of a symbol representation as one or many {@link Location locations}. +type Declaration = []Location // (alias) line 13833 +// @since 3.14.0 +type DeclarationClientCapabilities struct { // line 11509 + // Whether declaration supports dynamic registration. If this is set to `true` + // the client supports the new `DeclarationRegistrationOptions` return value + // for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports additional metadata in the form of declaration links. + LinkSupport bool `json:"linkSupport,omitempty"` +} + +// Information about where a symbol is declared. +// +// Provides additional metadata over normal {@link Location location} declarations, including the range of +// the declaring symbol. +// +// Servers should prefer returning `DeclarationLink` over `Declaration` if supported +// by the client. +type DeclarationLink = LocationLink // (alias) line 13853 +type DeclarationOptions struct { // line 6491 + WorkDoneProgressOptions +} +type DeclarationParams struct { // line 2494 + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} +type DeclarationRegistrationOptions struct { // line 2514 + DeclarationOptions + TextDocumentRegistrationOptions + StaticRegistrationOptions +} + +// The definition of a symbol represented as one or many {@link Location locations}. +// For most programming languages there is only one location at which a symbol is +// defined. +// +// Servers should prefer returning `DefinitionLink` over `Definition` if supported +// by the client. +type Definition = Or_Definition // (alias) line 13751 +// Client Capabilities for a {@link DefinitionRequest}. +type DefinitionClientCapabilities struct { // line 11534 + // Whether definition supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports additional metadata in the form of definition links. + // + // @since 3.14.0 + LinkSupport bool `json:"linkSupport,omitempty"` +} + +// Information about where a symbol is defined. +// +// Provides additional metadata over normal {@link Location location} definitions, including the range of +// the defining symbol +type DefinitionLink = LocationLink // (alias) line 13771 +// Server Capabilities for a {@link DefinitionRequest}. +type DefinitionOptions struct { // line 8919 + WorkDoneProgressOptions +} + +// Parameters for a {@link DefinitionRequest}. +type DefinitionParams struct { // line 5018 + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link DefinitionRequest}. +type DefinitionRegistrationOptions struct { // line 5039 + TextDocumentRegistrationOptions + DefinitionOptions +} + +// Delete file operation +type DeleteFile struct { // line 6794 + // A delete + Kind string `json:"kind"` + // The file to delete. + URI DocumentURI `json:"uri"` + // Delete options. + Options *DeleteFileOptions `json:"options,omitempty"` + ResourceOperation +} + +// Delete file options +type DeleteFileOptions struct { // line 9465 + // Delete the content recursively if a folder is denoted. + Recursive bool `json:"recursive,omitempty"` + // Ignore the operation if the file doesn't exist. + IgnoreIfNotExists bool `json:"ignoreIfNotExists,omitempty"` +} + +// The parameters sent in notifications/requests for user-initiated deletes of +// files. +// +// @since 3.16.0 +type DeleteFilesParams struct { // line 3300 + // An array of all files/folders deleted in this operation. + Files []FileDelete `json:"files"` +} + +// Represents a diagnostic, such as a compiler error or warning. Diagnostic objects +// are only valid in the scope of a resource. +type Diagnostic struct { // line 8525 + // The range at which the message applies + Range Range `json:"range"` + // The diagnostic's severity. Can be omitted. If omitted it is up to the + // client to interpret diagnostics as error, warning, info or hint. + Severity DiagnosticSeverity `json:"severity,omitempty"` + // The diagnostic's code, which usually appear in the user interface. + Code interface{} `json:"code,omitempty"` + // An optional property to describe the error code. + // Requires the code field (above) to be present/not null. + // + // @since 3.16.0 + CodeDescription *CodeDescription `json:"codeDescription,omitempty"` + // A human-readable string describing the source of this + // diagnostic, e.g. 'typescript' or 'super lint'. It usually + // appears in the user interface. + Source string `json:"source,omitempty"` + // The diagnostic's message. It usually appears in the user interface + Message string `json:"message"` + // Additional metadata about the diagnostic. + // + // @since 3.15.0 + Tags []DiagnosticTag `json:"tags,omitempty"` + // An array of related diagnostic information, e.g. when symbol-names within + // a scope collide all definitions can be marked via this property. + RelatedInformation []DiagnosticRelatedInformation `json:"relatedInformation,omitempty"` + // A data entry field that is preserved between a `textDocument/publishDiagnostics` + // notification and `textDocument/codeAction` request. + // + // @since 3.16.0 + Data interface{} `json:"data,omitempty"` +} + +// Client capabilities specific to diagnostic pull requests. +// +// @since 3.17.0 +type DiagnosticClientCapabilities struct { // line 12408 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + // return value for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Whether the clients supports related documents for document diagnostic pulls. + RelatedDocumentSupport bool `json:"relatedDocumentSupport,omitempty"` +} + +// Diagnostic options. +// +// @since 3.17.0 +type DiagnosticOptions struct { // line 7293 + // An optional identifier under which the diagnostics are + // managed by the client. + Identifier string `json:"identifier,omitempty"` + // Whether the language has inter file dependencies meaning that + // editing code in one file can result in a different diagnostic + // set in another file. Inter file dependencies are common for + // most programming languages and typically uncommon for linters. + InterFileDependencies bool `json:"interFileDependencies"` + // The server provides support for workspace diagnostics as well. + WorkspaceDiagnostics bool `json:"workspaceDiagnostics"` + WorkDoneProgressOptions +} + +// Diagnostic registration options. +// +// @since 3.17.0 +type DiagnosticRegistrationOptions struct { // line 3855 + TextDocumentRegistrationOptions + DiagnosticOptions + StaticRegistrationOptions +} + +// Represents a related message and source code location for a diagnostic. This should be +// used to point to code locations that cause or related to a diagnostics, e.g when duplicating +// a symbol in a scope. +type DiagnosticRelatedInformation struct { // line 10041 + // The location of this related diagnostic information. + Location Location `json:"location"` + // The message of this related diagnostic information. + Message string `json:"message"` +} + +// Cancellation data returned from a diagnostic request. +// +// @since 3.17.0 +type DiagnosticServerCancellationData struct { // line 3841 + RetriggerRequest bool `json:"retriggerRequest"` +} + +// The diagnostic's severity. +type DiagnosticSeverity uint32 // line 13504 +// The diagnostic tags. +// +// @since 3.15.0 +type DiagnosticTag uint32 // line 13534 +// Workspace client capabilities specific to diagnostic pull requests. +// +// @since 3.17.0 +type DiagnosticWorkspaceClientCapabilities struct { // line 11111 + // 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 + // pulled diagnostics 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 `json:"refreshSupport,omitempty"` +} +type DidChangeConfigurationClientCapabilities struct { // line 10837 + // Did change configuration notification supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// The parameters of a change configuration notification. +type DidChangeConfigurationParams struct { // line 4144 + // The actual changed settings + Settings interface{} `json:"settings"` +} +type DidChangeConfigurationRegistrationOptions struct { // line 4158 + Section *OrPSection_workspace_didChangeConfiguration `json:"section,omitempty"` +} + +// The params sent in a change notebook document notification. +// +// @since 3.17.0 +type DidChangeNotebookDocumentParams struct { // line 3974 + // The notebook document that did change. The version number points + // to the version after all provided changes have been applied. If + // only the text document content of a cell changes the notebook version + // doesn't necessarily have to change. + NotebookDocument VersionedNotebookDocumentIdentifier `json:"notebookDocument"` + // The actual changes to the notebook document. + // + // The changes describe single state changes to the notebook document. + // So if there are two changes c1 (at array index 0) and c2 (at array + // index 1) for a notebook in state S then c1 moves the notebook from + // S to S' and c2 from S' to S''. So c1 is computed on the state S and + // c2 is computed on the state S'. + // + // To mirror the content of a notebook using change events use the following approach: + // + // - start with the same initial content + // - apply the 'notebookDocument/didChange' notifications in the order you receive them. + // - apply the `NotebookChangeEvent`s in a single notification in the order + // you receive them. + Change NotebookDocumentChangeEvent `json:"change"` +} + +// The change text document notification's parameters. +type DidChangeTextDocumentParams struct { // line 4287 + // The document that did change. The version number points + // to the version after all provided content changes have + // been applied. + TextDocument VersionedTextDocumentIdentifier `json:"textDocument"` + // The actual content changes. The content changes describe single state changes + // to the document. So if there are two content changes c1 (at array index 0) and + // c2 (at array index 1) for a document in state S then c1 moves the document from + // S to S' and c2 from S' to S''. So c1 is computed on the state S and c2 is computed + // on the state S'. + // + // To mirror the content of a document using change events use the following approach: + // + // - start with the same initial content + // - apply the 'textDocument/didChange' notifications in the order you receive them. + // - apply the `TextDocumentContentChangeEvent`s in a single notification in the order + // you receive them. + ContentChanges []TextDocumentContentChangeEvent `json:"contentChanges"` +} +type DidChangeWatchedFilesClientCapabilities struct { // line 10851 + // Did change watched files notification supports dynamic registration. Please note + // that the current protocol doesn't support static configuration for file changes + // from the server side. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Whether the client has support for {@link RelativePattern relative pattern} + // or not. + // + // @since 3.17.0 + RelativePatternSupport bool `json:"relativePatternSupport,omitempty"` +} + +// The watched files change notification's parameters. +type DidChangeWatchedFilesParams struct { // line 4428 + // The actual file events. + Changes []FileEvent `json:"changes"` +} + +// Describe options to be used when registered for text document change events. +type DidChangeWatchedFilesRegistrationOptions struct { // line 4445 + // The watchers to register. + Watchers []FileSystemWatcher `json:"watchers"` +} + +// The parameters of a `workspace/didChangeWorkspaceFolders` notification. +type DidChangeWorkspaceFoldersParams struct { // line 2185 + // The actual workspace folder change event. + Event WorkspaceFoldersChangeEvent `json:"event"` +} + +// The params sent in a close notebook document notification. +// +// @since 3.17.0 +type DidCloseNotebookDocumentParams struct { // line 4012 + // The notebook document that got closed. + NotebookDocument NotebookDocumentIdentifier `json:"notebookDocument"` + // The text documents that represent the content + // of a notebook cell that got closed. + CellTextDocuments []TextDocumentIdentifier `json:"cellTextDocuments"` +} + +// The parameters sent in a close text document notification +type DidCloseTextDocumentParams struct { // line 4332 + // The document that was closed. + TextDocument TextDocumentIdentifier `json:"textDocument"` +} + +// The params sent in an open notebook document notification. +// +// @since 3.17.0 +type DidOpenNotebookDocumentParams struct { // line 3948 + // The notebook document that got opened. + NotebookDocument NotebookDocument `json:"notebookDocument"` + // The text documents that represent the content + // of a notebook cell. + CellTextDocuments []TextDocumentItem `json:"cellTextDocuments"` +} + +// The parameters sent in an open text document notification +type DidOpenTextDocumentParams struct { // line 4273 + // The document that was opened. + TextDocument TextDocumentItem `json:"textDocument"` +} + +// The params sent in a save notebook document notification. +// +// @since 3.17.0 +type DidSaveNotebookDocumentParams struct { // line 3997 + // The notebook document that got saved. + NotebookDocument NotebookDocumentIdentifier `json:"notebookDocument"` +} + +// The parameters sent in a save text document notification +type DidSaveTextDocumentParams struct { // line 4346 + // The document that was saved. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // Optional the content when saved. Depends on the includeText value + // when the save notification was requested. + Text *string `json:"text,omitempty"` +} +type DocumentColorClientCapabilities struct { // line 11875 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `DocumentColorRegistrationOptions` return value + // for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} +type DocumentColorOptions struct { // line 6471 + WorkDoneProgressOptions +} + +// Parameters for a {@link DocumentColorRequest}. +type DocumentColorParams struct { // line 2215 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + WorkDoneProgressParams + PartialResultParams +} +type DocumentColorRegistrationOptions struct { // line 2261 + TextDocumentRegistrationOptions + DocumentColorOptions + StaticRegistrationOptions +} + +// Parameters of the document diagnostic request. +// +// @since 3.17.0 +type DocumentDiagnosticParams struct { // line 3768 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The additional identifier provided during registration. + Identifier string `json:"identifier,omitempty"` + // The result id of a previous response if provided. + PreviousResultID string `json:"previousResultId,omitempty"` + WorkDoneProgressParams + PartialResultParams +} +type DocumentDiagnosticReport = Or_DocumentDiagnosticReport // (alias) line 13909 +// The document diagnostic report kinds. +// +// @since 3.17.0 +type DocumentDiagnosticReportKind string // line 12722 +// A partial result for a document diagnostic report. +// +// @since 3.17.0 +type DocumentDiagnosticReportPartialResult struct { // line 3811 + RelatedDocuments map[DocumentURI]interface{} `json:"relatedDocuments"` +} + +// A document filter describes a top level text document or +// a notebook cell document. +// +// @since 3.17.0 - proposed support for NotebookCellTextDocumentFilter. +type DocumentFilter = Or_DocumentFilter // (alias) line 14093 +// Client capabilities of a {@link DocumentFormattingRequest}. +type DocumentFormattingClientCapabilities struct { // line 11889 + // Whether formatting supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// Provider options for a {@link DocumentFormattingRequest}. +type DocumentFormattingOptions struct { // line 9221 + WorkDoneProgressOptions +} + +// The parameters of a {@link DocumentFormattingRequest}. +type DocumentFormattingParams struct { // line 5727 + // The document to format. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The format options. + Options FormattingOptions `json:"options"` + WorkDoneProgressParams +} + +// Registration options for a {@link DocumentFormattingRequest}. +type DocumentFormattingRegistrationOptions struct { // line 5755 + TextDocumentRegistrationOptions + DocumentFormattingOptions +} + +// A document highlight is a range inside a text document which deserves +// special attention. Usually a document highlight is visualized by changing +// the background color of its range. +type DocumentHighlight struct { // line 5119 + // The range this highlight applies to. + Range Range `json:"range"` + // The highlight kind, default is {@link DocumentHighlightKind.Text text}. + Kind DocumentHighlightKind `json:"kind,omitempty"` +} + +// Client Capabilities for a {@link DocumentHighlightRequest}. +type DocumentHighlightClientCapabilities struct { // line 11624 + // Whether document highlight supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// A document highlight kind. +type DocumentHighlightKind uint32 // line 13301 +// Provider options for a {@link DocumentHighlightRequest}. +type DocumentHighlightOptions struct { // line 8955 + WorkDoneProgressOptions +} + +// Parameters for a {@link DocumentHighlightRequest}. +type DocumentHighlightParams struct { // line 5098 + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link DocumentHighlightRequest}. +type DocumentHighlightRegistrationOptions struct { // line 5142 + TextDocumentRegistrationOptions + DocumentHighlightOptions +} + +// A document link is a range in a text document that links to an internal or external resource, like another +// text document or a web site. +type DocumentLink struct { // line 5670 + // The range this link applies to. + Range Range `json:"range"` + // The uri this link points to. If missing a resolve request is sent later. + Target string `json:"target,omitempty"` + // The tooltip text when you hover over this link. + // + // If a tooltip is provided, is will be displayed in a string that includes instructions on how to + // trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS, + // user settings, and localization. + // + // @since 3.15.0 + Tooltip string `json:"tooltip,omitempty"` + // A data entry field that is preserved on a document link between a + // DocumentLinkRequest and a DocumentLinkResolveRequest. + Data interface{} `json:"data,omitempty"` +} + +// The client capabilities of a {@link DocumentLinkRequest}. +type DocumentLinkClientCapabilities struct { // line 11850 + // Whether document link supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Whether the client supports the `tooltip` property on `DocumentLink`. + // + // @since 3.15.0 + TooltipSupport bool `json:"tooltipSupport,omitempty"` +} + +// Provider options for a {@link DocumentLinkRequest}. +type DocumentLinkOptions struct { // line 9148 + // Document links have a resolve provider as well. + ResolveProvider bool `json:"resolveProvider,omitempty"` + WorkDoneProgressOptions +} + +// The parameters of a {@link DocumentLinkRequest}. +type DocumentLinkParams struct { // line 5646 + // The document to provide document links for. + TextDocument TextDocumentIdentifier `json:"textDocument"` + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link DocumentLinkRequest}. +type DocumentLinkRegistrationOptions struct { // line 5712 + TextDocumentRegistrationOptions + DocumentLinkOptions +} + +// Client capabilities of a {@link DocumentOnTypeFormattingRequest}. +type DocumentOnTypeFormattingClientCapabilities struct { // line 11919 + // Whether on type formatting supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// Provider options for a {@link DocumentOnTypeFormattingRequest}. +type DocumentOnTypeFormattingOptions struct { // line 9243 + // A character on which formatting should be triggered, like `{`. + FirstTriggerCharacter string `json:"firstTriggerCharacter"` + // More trigger characters. + MoreTriggerCharacter []string `json:"moreTriggerCharacter,omitempty"` +} + +// The parameters of a {@link DocumentOnTypeFormattingRequest}. +type DocumentOnTypeFormattingParams struct { // line 5821 + // The document to format. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The position around which the on type formatting should happen. + // This is not necessarily the exact position where the character denoted + // by the property `ch` got typed. + Position Position `json:"position"` + // The character that has been typed that triggered the formatting + // on type request. That is not necessarily the last character that + // got inserted into the document since the client could auto insert + // characters as well (e.g. like automatic brace completion). + Ch string `json:"ch"` + // The formatting options. + Options FormattingOptions `json:"options"` +} + +// Registration options for a {@link DocumentOnTypeFormattingRequest}. +type DocumentOnTypeFormattingRegistrationOptions struct { // line 5859 + TextDocumentRegistrationOptions + DocumentOnTypeFormattingOptions +} + +// Client capabilities of a {@link DocumentRangeFormattingRequest}. +type DocumentRangeFormattingClientCapabilities struct { // line 11904 + // Whether range formatting supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// Provider options for a {@link DocumentRangeFormattingRequest}. +type DocumentRangeFormattingOptions struct { // line 9232 + WorkDoneProgressOptions +} + +// The parameters of a {@link DocumentRangeFormattingRequest}. +type DocumentRangeFormattingParams struct { // line 5770 + // The document to format. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The range to format + Range Range `json:"range"` + // The format options + Options FormattingOptions `json:"options"` + WorkDoneProgressParams +} + +// Registration options for a {@link DocumentRangeFormattingRequest}. +type DocumentRangeFormattingRegistrationOptions struct { // line 5806 + TextDocumentRegistrationOptions + DocumentRangeFormattingOptions +} + +// A document selector is the combination of one or many document filters. +// +// @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`; +// +// The use of a string as a document filter is deprecated @since 3.16.0. +type DocumentSelector = []DocumentFilter // (alias) line 13948 +// 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. +type DocumentSymbol struct { // line 5211 + // 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. + Name string `json:"name"` + // More detail for this symbol, e.g the signature of a function. + Detail string `json:"detail,omitempty"` + // The kind of this symbol. + Kind SymbolKind `json:"kind"` + // Tags for this document symbol. + // + // @since 3.16.0 + Tags []SymbolTag `json:"tags,omitempty"` + // Indicates if this symbol is deprecated. + // + // @deprecated Use tags instead + Deprecated bool `json:"deprecated,omitempty"` + // 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. + Range Range `json:"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 `json:"selectionRange"` + // Children of this symbol, e.g. properties of a class. + Children []DocumentSymbol `json:"children,omitempty"` +} + +// Client Capabilities for a {@link DocumentSymbolRequest}. +type DocumentSymbolClientCapabilities struct { // line 11639 + // Whether document symbol supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Specific capabilities for the `SymbolKind` in the + // `textDocument/documentSymbol` request. + SymbolKind *PSymbolKindPDocumentSymbol `json:"symbolKind,omitempty"` + // The client supports hierarchical document symbols. + HierarchicalDocumentSymbolSupport bool `json:"hierarchicalDocumentSymbolSupport,omitempty"` + // The client supports tags on `SymbolInformation`. Tags are supported on + // `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true. + // Clients supporting tags have to handle unknown tags gracefully. + // + // @since 3.16.0 + TagSupport *PTagSupportPDocumentSymbol `json:"tagSupport,omitempty"` + // The client supports an additional label presented in the UI when + // registering a document symbol provider. + // + // @since 3.16.0 + LabelSupport bool `json:"labelSupport,omitempty"` +} + +// Provider options for a {@link DocumentSymbolRequest}. +type DocumentSymbolOptions struct { // line 9010 + // A human-readable string that is shown when multiple outlines trees + // are shown for the same document. + // + // @since 3.16.0 + Label string `json:"label,omitempty"` + WorkDoneProgressOptions +} + +// Parameters for a {@link DocumentSymbolRequest}. +type DocumentSymbolParams struct { // line 5157 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link DocumentSymbolRequest}. +type DocumentSymbolRegistrationOptions struct { // line 5293 + TextDocumentRegistrationOptions + DocumentSymbolOptions +} +type DocumentURI string + +// Predefined error codes. +type ErrorCodes int32 // line 12743 +// The client capabilities of a {@link ExecuteCommandRequest}. +type ExecuteCommandClientCapabilities struct { // line 10962 + // Execute command supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// The server capabilities of a {@link ExecuteCommandRequest}. +type ExecuteCommandOptions struct { // line 9291 + // The commands to be executed on the server + Commands []string `json:"commands"` + WorkDoneProgressOptions +} + +// The parameters of a {@link ExecuteCommandRequest}. +type ExecuteCommandParams struct { // line 5941 + // The identifier of the actual command handler. + Command string `json:"command"` + // Arguments that the command should be invoked with. + Arguments []json.RawMessage `json:"arguments,omitempty"` + WorkDoneProgressParams +} + +// Registration options for a {@link ExecuteCommandRequest}. +type ExecuteCommandRegistrationOptions struct { // line 5973 + ExecuteCommandOptions +} +type ExecutionSummary struct { // line 10162 + // A strict monotonically increasing value + // indicating the execution order of a cell + // inside a notebook. + ExecutionOrder uint32 `json:"executionOrder"` + // Whether the execution was successful or + // not if known by the client. + Success bool `json:"success,omitempty"` +} + +// created for Literal (Lit_CodeActionClientCapabilities_codeActionLiteralSupport_codeActionKind) +type FCodeActionKindPCodeActionLiteralSupport struct { // line 11742 + // The code action kind values the client supports. When this + // property exists the client also guarantees that it will + // handle values outside its set gracefully and falls back + // to a default value when unknown. + ValueSet []CodeActionKind `json:"valueSet"` +} + +// created for Literal (Lit_CompletionList_itemDefaults_editRange_Item1) +type FEditRangePItemDefaults struct { // line 4777 + Insert Range `json:"insert"` + Replace Range `json:"replace"` +} + +// created for Literal (Lit_SemanticTokensClientCapabilities_requests_full_Item1) +type FFullPRequests struct { // line 12205 + // The client will send the `textDocument/semanticTokens/full/delta` request if + // the server provides a corresponding handler. + Delta bool `json:"delta"` +} + +// created for Literal (Lit_CompletionClientCapabilities_completionItem_insertTextModeSupport) +type FInsertTextModeSupportPCompletionItem struct { // line 11295 + ValueSet []InsertTextMode `json:"valueSet"` +} + +// created for Literal (Lit_SignatureHelpClientCapabilities_signatureInformation_parameterInformation) +type FParameterInformationPSignatureInformation struct { // line 11461 + // The client supports processing label offsets instead of a + // simple label string. + // + // @since 3.14.0 + LabelOffsetSupport bool `json:"labelOffsetSupport,omitempty"` +} + +// created for Literal (Lit_SemanticTokensClientCapabilities_requests_range_Item1) +type FRangePRequests struct { // line 12185 +} + +// created for Literal (Lit_CompletionClientCapabilities_completionItem_resolveSupport) +type FResolveSupportPCompletionItem struct { // line 11271 + // The properties that a client can resolve lazily. + Properties []string `json:"properties"` +} + +// created for Literal (Lit_NotebookDocumentChangeEvent_cells_structure) +type FStructurePCells struct { // line 7487 + // The change to the cell array. + Array NotebookCellArrayChange `json:"array"` + // Additional opened cell text documents. + DidOpen []TextDocumentItem `json:"didOpen,omitempty"` + // Additional closed cell text documents. + DidClose []TextDocumentIdentifier `json:"didClose,omitempty"` +} + +// created for Literal (Lit_CompletionClientCapabilities_completionItem_tagSupport) +type FTagSupportPCompletionItem struct { // line 11237 + // The tags supported by the client. + ValueSet []CompletionItemTag `json:"valueSet"` +} +type FailureHandlingKind string // line 13693 +// The file event type +type FileChangeType uint32 // line 13454 +// Represents information on a file/folder create. +// +// @since 3.16.0 +type FileCreate struct { // line 6662 + // A file:// URI for the location of the file/folder being created. + URI string `json:"uri"` +} + +// Represents information on a file/folder delete. +// +// @since 3.16.0 +type FileDelete struct { // line 6911 + // A file:// URI for the location of the file/folder being deleted. + URI string `json:"uri"` +} + +// An event describing a file change. +type FileEvent struct { // line 8480 + // The file's uri. + URI DocumentURI `json:"uri"` + // The change type. + Type FileChangeType `json:"type"` +} + +// Capabilities relating to events from file operations by the user in the client. +// +// These events do not come from the file system, they come from user operations +// like renaming a file in the UI. +// +// @since 3.16.0 +type FileOperationClientCapabilities struct { // line 11009 + // Whether the client supports dynamic registration for file requests/notifications. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client has support for sending didCreateFiles notifications. + DidCreate bool `json:"didCreate,omitempty"` + // The client has support for sending willCreateFiles requests. + WillCreate bool `json:"willCreate,omitempty"` + // The client has support for sending didRenameFiles notifications. + DidRename bool `json:"didRename,omitempty"` + // The client has support for sending willRenameFiles requests. + WillRename bool `json:"willRename,omitempty"` + // The client has support for sending didDeleteFiles notifications. + DidDelete bool `json:"didDelete,omitempty"` + // The client has support for sending willDeleteFiles requests. + WillDelete bool `json:"willDelete,omitempty"` +} + +// A filter to describe in which file operation requests or notifications +// the server is interested in receiving. +// +// @since 3.16.0 +type FileOperationFilter struct { // line 6864 + // A Uri scheme like `file` or `untitled`. + Scheme string `json:"scheme,omitempty"` + // The actual file operation pattern. + Pattern FileOperationPattern `json:"pattern"` +} + +// Options for notifications/requests for user operations on files. +// +// @since 3.16.0 +type FileOperationOptions struct { // line 9965 + // The server is interested in receiving didCreateFiles notifications. + DidCreate *FileOperationRegistrationOptions `json:"didCreate,omitempty"` + // The server is interested in receiving willCreateFiles requests. + WillCreate *FileOperationRegistrationOptions `json:"willCreate,omitempty"` + // The server is interested in receiving didRenameFiles notifications. + DidRename *FileOperationRegistrationOptions `json:"didRename,omitempty"` + // The server is interested in receiving willRenameFiles requests. + WillRename *FileOperationRegistrationOptions `json:"willRename,omitempty"` + // The server is interested in receiving didDeleteFiles file notifications. + DidDelete *FileOperationRegistrationOptions `json:"didDelete,omitempty"` + // The server is interested in receiving willDeleteFiles file requests. + WillDelete *FileOperationRegistrationOptions `json:"willDelete,omitempty"` +} + +// A pattern to describe in which file operation requests or notifications +// the server is interested in receiving. +// +// @since 3.16.0 +type FileOperationPattern struct { // line 9489 + // The glob pattern to match. Glob patterns can have the following syntax: + // + // - `*` to match one or more characters in a path segment + // - `?` to match on one character in a path segment + // - `**` to match any number of path segments, including none + // - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files) + // - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) + // - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) + Glob string `json:"glob"` + // Whether to match files or folders with this pattern. + // + // Matches both if undefined. + Matches *FileOperationPatternKind `json:"matches,omitempty"` + // Additional options used during matching. + Options *FileOperationPatternOptions `json:"options,omitempty"` +} + +// A pattern kind describing if a glob pattern matches a file a folder or +// both. +// +// @since 3.16.0 +type FileOperationPatternKind string // line 13627 +// Matching options for the file operation pattern. +// +// @since 3.16.0 +type FileOperationPatternOptions struct { // line 10146 + // The pattern should be matched ignoring casing. + IgnoreCase bool `json:"ignoreCase,omitempty"` +} + +// The options to register for file operations. +// +// @since 3.16.0 +type FileOperationRegistrationOptions struct { // line 3264 + // The actual filters. + Filters []FileOperationFilter `json:"filters"` +} + +// Represents information on a file/folder rename. +// +// @since 3.16.0 +type FileRename struct { // line 6888 + // A file:// URI for the original location of the file/folder being renamed. + OldURI string `json:"oldUri"` + // A file:// URI for the new location of the file/folder being renamed. + NewURI string `json:"newUri"` +} +type FileSystemWatcher struct { // line 8502 + // The glob pattern to watch. See {@link GlobPattern glob pattern} for more detail. + // + // @since 3.17.0 support for relative patterns. + GlobPattern GlobPattern `json:"globPattern"` + // The kind of events of interest. If omitted it defaults + // to WatchKind.Create | WatchKind.Change | WatchKind.Delete + // which is 7. + Kind *WatchKind `json:"kind,omitempty"` +} + +// Represents a folding range. To be valid, start and end line must be bigger than zero and smaller +// than the number of lines in the document. Clients are free to ignore invalid ranges. +type FoldingRange struct { // line 2415 + // The zero-based start line of the range to fold. The folded area starts after the line's last character. + // To be valid, the end must be zero or larger and smaller than the number of lines in the document. + StartLine uint32 `json:"startLine"` + // The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line. + StartCharacter uint32 `json:"startCharacter,omitempty"` + // The zero-based end line of the range to fold. The folded area ends with the line's last character. + // To be valid, the end must be zero or larger and smaller than the number of lines in the document. + EndLine uint32 `json:"endLine"` + // The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line. + EndCharacter uint32 `json:"endCharacter,omitempty"` + // Describes the kind of the folding range such as `comment' or 'region'. The kind + // is used to categorize folding ranges and used by commands like 'Fold all comments'. + // See {@link FoldingRangeKind} for an enumeration of standardized kinds. + Kind string `json:"kind,omitempty"` + // The text that the client should show when the specified range is + // collapsed. If not defined or not supported by the client, a default + // will be chosen by the client. + // + // @since 3.17.0 + CollapsedText string `json:"collapsedText,omitempty"` +} +type FoldingRangeClientCapabilities struct { // line 11978 + // Whether implementation supports dynamic registration for folding range + // providers. If this is set to `true` the client supports the new + // `FoldingRangeRegistrationOptions` return value for the corresponding + // server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The maximum number of folding ranges that the client prefers to receive + // per document. The value serves as a hint, servers are free to follow the + // limit. + RangeLimit uint32 `json:"rangeLimit,omitempty"` + // If set, the client signals that it only supports folding complete lines. + // If set, client will ignore specified `startCharacter` and `endCharacter` + // properties in a FoldingRange. + LineFoldingOnly bool `json:"lineFoldingOnly,omitempty"` + // Specific options for the folding range kind. + // + // @since 3.17.0 + FoldingRangeKind *PFoldingRangeKindPFoldingRange `json:"foldingRangeKind,omitempty"` + // Specific options for the folding range. + // + // @since 3.17.0 + FoldingRange *PFoldingRangePFoldingRange `json:"foldingRange,omitempty"` +} + +// A set of predefined range kinds. +type FoldingRangeKind string // line 12815 +type FoldingRangeOptions struct { // line 6481 + WorkDoneProgressOptions +} + +// Parameters for a {@link FoldingRangeRequest}. +type FoldingRangeParams struct { // line 2391 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + WorkDoneProgressParams + PartialResultParams +} +type FoldingRangeRegistrationOptions struct { // line 2474 + TextDocumentRegistrationOptions + FoldingRangeOptions + StaticRegistrationOptions +} + +// Value-object describing what options formatting should use. +type FormattingOptions struct { // line 9169 + // Size of a tab in spaces. + TabSize uint32 `json:"tabSize"` + // Prefer spaces over tabs. + InsertSpaces bool `json:"insertSpaces"` + // Trim trailing whitespace on a line. + // + // @since 3.15.0 + TrimTrailingWhitespace bool `json:"trimTrailingWhitespace,omitempty"` + // Insert a newline character at the end of the file if one does not exist. + // + // @since 3.15.0 + InsertFinalNewline bool `json:"insertFinalNewline,omitempty"` + // Trim all newlines after the final newline at the end of the file. + // + // @since 3.15.0 + TrimFinalNewlines bool `json:"trimFinalNewlines,omitempty"` +} + +// A diagnostic report with a full set of problems. +// +// @since 3.17.0 +type FullDocumentDiagnosticReport struct { // line 7235 + // A full document diagnostic report. + Kind string `json:"kind"` + // An optional result id. If provided it will + // be sent on the next diagnostic request for the + // same document. + ResultID string `json:"resultId,omitempty"` + // The actual items. + Items []Diagnostic `json:"items"` +} + +// General client capabilities. +// +// @since 3.16.0 +type GeneralClientCapabilities struct { // line 10664 + // Client capability that signals how the client + // handles stale requests (e.g. a request + // for which the client will not process the response + // anymore since the information is outdated). + // + // @since 3.17.0 + StaleRequestSupport *PStaleRequestSupportPGeneral `json:"staleRequestSupport,omitempty"` + // Client capabilities specific to regular expressions. + // + // @since 3.16.0 + RegularExpressions *RegularExpressionsClientCapabilities `json:"regularExpressions,omitempty"` + // Client capabilities specific to the client's markdown parser. + // + // @since 3.16.0 + Markdown *MarkdownClientCapabilities `json:"markdown,omitempty"` + // The position encodings supported by the client. Client and server + // have to agree on the same position encoding to ensure that offsets + // (e.g. character position in a line) are interpreted the same on both + // sides. + // + // To keep the protocol backwards compatible the following applies: if + // the value 'utf-16' is missing from the array of position encodings + // servers can assume that the client supports UTF-16. UTF-16 is + // therefore a mandatory encoding. + // + // If omitted it defaults to ['utf-16']. + // + // Implementation considerations: since the conversion from one encoding + // into another requires the content of the file / line the conversion + // is best done where the file is read which is usually on the server + // side. + // + // @since 3.17.0 + PositionEncodings []PositionEncodingKind `json:"positionEncodings,omitempty"` +} + +// The glob pattern. Either a string pattern or a relative pattern. +// +// @since 3.17.0 +type GlobPattern = string // (alias) line 14127 +// The result of a hover request. +type Hover struct { // line 4886 + // The hover's content + Contents MarkupContent `json:"contents"` + // An optional range inside the text document that is used to + // visualize the hover, e.g. by changing the background color. + Range Range `json:"range,omitempty"` +} +type HoverClientCapabilities struct { // line 11402 + // Whether hover supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Client supports the following content formats for the content + // property. The order describes the preferred format of the client. + ContentFormat []MarkupKind `json:"contentFormat,omitempty"` +} + +// Hover options. +type HoverOptions struct { // line 8776 + WorkDoneProgressOptions +} + +// Parameters for a {@link HoverRequest}. +type HoverParams struct { // line 4869 + TextDocumentPositionParams + WorkDoneProgressParams +} + +// Registration options for a {@link HoverRequest}. +type HoverRegistrationOptions struct { // line 4925 + TextDocumentRegistrationOptions + HoverOptions +} + +// @since 3.6.0 +type ImplementationClientCapabilities struct { // line 11583 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `ImplementationRegistrationOptions` return value + // for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports additional metadata in the form of definition links. + // + // @since 3.14.0 + LinkSupport bool `json:"linkSupport,omitempty"` +} +type ImplementationOptions struct { // line 6333 + WorkDoneProgressOptions +} +type ImplementationParams struct { // line 2063 + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} +type ImplementationRegistrationOptions struct { // line 2103 + TextDocumentRegistrationOptions + ImplementationOptions + StaticRegistrationOptions +} + +// The data type of the ResponseError if the +// initialize request fails. +type InitializeError struct { // line 4126 + // Indicates whether the client execute the following retry logic: + // (1) show the message provided by the ResponseError to the user + // (2) user selects retry or cancel + // (3) if user selected retry the initialize method is sent again. + Retry bool `json:"retry"` +} +type InitializeParams struct { // line 4068 + XInitializeParams + WorkspaceFoldersInitializeParams +} + +// The result returned from an initialize request. +type InitializeResult struct { // line 4082 + // The capabilities the language server provides. + Capabilities ServerCapabilities `json:"capabilities"` + // Information about the server. + // + // @since 3.15.0 + ServerInfo *PServerInfoMsg_initialize `json:"serverInfo,omitempty"` +} +type InitializedParams struct { // line 4140 +} + +// Inlay hint information. +// +// @since 3.17.0 +type InlayHint struct { // line 3645 + // The position of this hint. + Position Position `json:"position"` + // The label of this hint. A human readable string or an array of + // InlayHintLabelPart label parts. + // + // *Note* that neither the string nor the label part can be empty. + Label []InlayHintLabelPart `json:"label"` + // The kind of this hint. Can be omitted in which case the client + // should fall back to a reasonable default. + Kind InlayHintKind `json:"kind,omitempty"` + // Optional text edits that are performed when accepting this inlay hint. + // + // *Note* that edits are expected to change the document so that the inlay + // hint (or its nearest variant) is now part of the document and the inlay + // hint itself is now obsolete. + TextEdits []TextEdit `json:"textEdits,omitempty"` + // The tooltip text when you hover over this item. + Tooltip *OrPTooltip_textDocument_inlayHint `json:"tooltip,omitempty"` + // Render padding before the hint. + // + // Note: Padding should use the editor's background color, not the + // background color of the hint itself. That means padding can be used + // to visually align/separate an inlay hint. + PaddingLeft bool `json:"paddingLeft,omitempty"` + // Render padding after the hint. + // + // Note: Padding should use the editor's background color, not the + // background color of the hint itself. That means padding can be used + // to visually align/separate an inlay hint. + PaddingRight bool `json:"paddingRight,omitempty"` + // A data entry field that is preserved on an inlay hint between + // a `textDocument/inlayHint` and a `inlayHint/resolve` request. + Data interface{} `json:"data,omitempty"` +} + +// Inlay hint client capabilities. +// +// @since 3.17.0 +type InlayHintClientCapabilities struct { // line 12369 + // Whether inlay hints support dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Indicates which properties a client can resolve lazily on an inlay + // hint. + ResolveSupport *PResolveSupportPInlayHint `json:"resolveSupport,omitempty"` +} + +// Inlay hint kinds. +// +// @since 3.17.0 +type InlayHintKind uint32 // line 13033 +// An inlay hint label part allows for interactive and composite labels +// of inlay hints. +// +// @since 3.17.0 +type InlayHintLabelPart struct { // line 7062 + // The value of this label part. + Value string `json:"value"` + // The tooltip text when you hover over this label part. Depending on + // the client capability `inlayHint.resolveSupport` clients might resolve + // this property late using the resolve request. + Tooltip *OrPTooltipPLabel `json:"tooltip,omitempty"` + // An optional source code location that represents this + // label part. + // + // The editor will use this location for the hover and for code navigation + // features: This part will become a clickable link that resolves to the + // definition of the symbol at the given location (not necessarily the + // location itself), it shows the hover that shows at the given location, + // and it shows a context menu with further code navigation commands. + // + // Depending on the client capability `inlayHint.resolveSupport` clients + // might resolve this property late using the resolve request. + Location *Location `json:"location,omitempty"` + // An optional command for this label part. + // + // Depending on the client capability `inlayHint.resolveSupport` clients + // might resolve this property late using the resolve request. + Command *Command `json:"command,omitempty"` +} + +// Inlay hint options used during static registration. +// +// @since 3.17.0 +type InlayHintOptions struct { // line 7135 + // The server provides support to resolve additional + // information for an inlay hint item. + ResolveProvider bool `json:"resolveProvider,omitempty"` + WorkDoneProgressOptions +} + +// A parameter literal used in inlay hint requests. +// +// @since 3.17.0 +type InlayHintParams struct { // line 3616 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The document range for which inlay hints should be computed. + Range Range `json:"range"` + WorkDoneProgressParams +} + +// Inlay hint options used during static or dynamic registration. +// +// @since 3.17.0 +type InlayHintRegistrationOptions struct { // line 3746 + InlayHintOptions + TextDocumentRegistrationOptions + StaticRegistrationOptions +} + +// Client workspace capabilities specific to inlay hints. +// +// @since 3.17.0 +type InlayHintWorkspaceClientCapabilities struct { // line 11095 + // 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 + // inlay hints 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 `json:"refreshSupport,omitempty"` +} + +// Inline value information can be provided by different means: +// +// - directly as a text value (class InlineValueText). +// - as a name to use for a variable lookup (class InlineValueVariableLookup) +// - as an evaluatable expression (class InlineValueEvaluatableExpression) +// +// The InlineValue types combines all inline value types into one type. +// +// @since 3.17.0 +type InlineValue = Or_InlineValue // (alias) line 13861 +// Client capabilities specific to inline values. +// +// @since 3.17.0 +type InlineValueClientCapabilities struct { // line 12353 + // Whether implementation supports dynamic registration for inline value providers. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// @since 3.17.0 +type InlineValueContext struct { // line 6948 + // The stack frame (as a DAP Id) where the execution has stopped. + FrameID int32 `json:"frameId"` + // 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 `json:"stoppedLocation"` +} + +// Provide an inline value through an expression evaluation. +// If only a range is specified, the expression will be extracted from the underlying document. +// An optional expression can be used to override the extracted expression. +// +// @since 3.17.0 +type InlineValueEvaluatableExpression struct { // line 7026 + // The document range for which the inline value applies. + // The range is used to extract the evaluatable expression from the underlying document. + Range Range `json:"range"` + // If specified the expression overrides the extracted expression. + Expression string `json:"expression,omitempty"` +} + +// Inline value options used during static registration. +// +// @since 3.17.0 +type InlineValueOptions struct { // line 7050 + WorkDoneProgressOptions +} + +// A parameter literal used in inline value requests. +// +// @since 3.17.0 +type InlineValueParams struct { // line 3557 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The document range for which inline values should be computed. + Range Range `json:"range"` + // Additional information about the context in which inline values were + // requested. + Context InlineValueContext `json:"context"` + WorkDoneProgressParams +} + +// Inline value options used during static or dynamic registration. +// +// @since 3.17.0 +type InlineValueRegistrationOptions struct { // line 3594 + InlineValueOptions + TextDocumentRegistrationOptions + StaticRegistrationOptions +} + +// Provide inline value as text. +// +// @since 3.17.0 +type InlineValueText struct { // line 6971 + // The document range for which the inline value applies. + Range Range `json:"range"` + // The text of the inline value. + Text string `json:"text"` +} + +// Provide inline value through a variable lookup. +// If only a range is specified, the variable name will be extracted from the underlying document. +// An optional variable name can be used to override the extracted name. +// +// @since 3.17.0 +type InlineValueVariableLookup struct { // line 6994 + // The document range for which the inline value applies. + // The range is used to extract the variable name from the underlying document. + Range Range `json:"range"` + // If specified the name of the variable to look up. + VariableName string `json:"variableName,omitempty"` + // How to perform the lookup. + CaseSensitiveLookup bool `json:"caseSensitiveLookup"` +} + +// Client workspace capabilities specific to inline values. +// +// @since 3.17.0 +type InlineValueWorkspaceClientCapabilities struct { // line 11079 + // 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 `json:"refreshSupport,omitempty"` +} + +// A special text edit to provide an insert and a replace operation. +// +// @since 3.16.0 +type InsertReplaceEdit struct { // line 8676 + // The string to be inserted. + NewText string `json:"newText"` + // The range if the insert is requested + Insert Range `json:"insert"` + // The range if the replace is requested. + Replace Range `json:"replace"` +} + +// Defines whether the insert text in a completion item should be interpreted as +// plain text or a snippet. +type InsertTextFormat uint32 // line 13260 +// How whitespace and indentation is handled during completion +// item insertion. +// +// @since 3.16.0 +type InsertTextMode uint32 // line 13280 +type LSPAny = interface{} + +// LSP arrays. +// @since 3.17.0 +type LSPArray = []interface{} // (alias) line 13779 +type LSPErrorCodes int32 // line 12783 +// LSP object definition. +// @since 3.17.0 +type LSPObject = map[string]LSPAny // (alias) line 14111 +// Client capabilities for the linked editing range request. +// +// @since 3.16.0 +type LinkedEditingRangeClientCapabilities struct { // line 12305 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + // return value for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} +type LinkedEditingRangeOptions struct { // line 6652 + WorkDoneProgressOptions +} +type LinkedEditingRangeParams struct { // line 3112 + TextDocumentPositionParams + WorkDoneProgressParams +} +type LinkedEditingRangeRegistrationOptions struct { // line 3155 + TextDocumentRegistrationOptions + LinkedEditingRangeOptions + StaticRegistrationOptions +} + +// The result of a linked editing range request. +// +// @since 3.16.0 +type LinkedEditingRanges struct { // line 3128 + // A list of ranges that can be edited together. The ranges must have + // identical length and contain identical text content. The ranges cannot overlap. + Ranges []Range `json:"ranges"` + // An optional word pattern (regular expression) that describes valid contents for + // the given ranges. If no pattern is provided, the client configuration's word + // pattern will be used. + WordPattern string `json:"wordPattern,omitempty"` +} + +// created for Literal (Lit_NotebookDocumentChangeEvent_cells_textContent_Elem) +type Lit_NotebookDocumentChangeEvent_cells_textContent_Elem struct { // line 7545 + Document VersionedTextDocumentIdentifier `json:"document"` + Changes []TextDocumentContentChangeEvent `json:"changes"` +} + +// created for Literal (Lit_NotebookDocumentFilter_Item1) +type Lit_NotebookDocumentFilter_Item1 struct { // line 14293 + // The type of the enclosing notebook. + NotebookType string `json:"notebookType,omitempty"` + // A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. + Scheme string `json:"scheme"` + // A glob pattern. + Pattern string `json:"pattern,omitempty"` +} + +// created for Literal (Lit_NotebookDocumentFilter_Item2) +type Lit_NotebookDocumentFilter_Item2 struct { // line 14326 + // The type of the enclosing notebook. + NotebookType string `json:"notebookType,omitempty"` + // A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. + Scheme string `json:"scheme,omitempty"` + // A glob pattern. + Pattern string `json:"pattern"` +} + +// created for Literal (Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item0_cells_Elem) +type Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item0_cells_Elem struct { // line 9831 + Language string `json:"language"` +} + +// created for Literal (Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1) +type Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1 struct { // line 9852 + // The notebook to be synced If a string + // value is provided it matches against the + // notebook type. '*' matches every notebook. + Notebook *Or_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_notebook `json:"notebook,omitempty"` + // The cells of the matching notebook to be synced. + Cells []Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_cells_Elem `json:"cells"` +} + +// created for Literal (Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_cells_Elem) +type Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_cells_Elem struct { // line 9878 + Language string `json:"language"` +} + +// created for Literal (Lit_PrepareRenameResult_Item2) +type Lit_PrepareRenameResult_Item2 struct { // line 13932 + DefaultBehavior bool `json:"defaultBehavior"` +} + +// created for Literal (Lit_TextDocumentContentChangeEvent_Item1) +type Lit_TextDocumentContentChangeEvent_Item1 struct { // line 14040 + // The new text of the whole document. + Text string `json:"text"` +} + +// created for Literal (Lit_TextDocumentFilter_Item2) +type Lit_TextDocumentFilter_Item2 struct { // line 14217 + // A language id, like `typescript`. + Language string `json:"language,omitempty"` + // A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. + Scheme string `json:"scheme,omitempty"` + // A glob pattern, like `*.{ts,js}`. + Pattern string `json:"pattern"` +} + +// Represents a location inside a resource, such as a line +// inside a text file. +type Location struct { // line 2083 + URI DocumentURI `json:"uri"` + Range Range `json:"range"` +} + +// Represents the connection of two locations. Provides additional metadata over normal {@link Location locations}, +// including an origin range. +type LocationLink struct { // line 6272 + // Span of the origin of this link. + // + // Used as the underlined span for mouse interaction. Defaults to the word range at + // the definition position. + OriginSelectionRange *Range `json:"originSelectionRange,omitempty"` + // The target resource identifier of this link. + TargetURI DocumentURI `json:"targetUri"` + // The full target range of this link. If the target for example is a symbol then target range is the + // range enclosing this symbol not including leading/trailing whitespace but everything else + // like comments. This information is typically used to highlight the range in the editor. + TargetRange Range `json:"targetRange"` + // The range that should be selected and revealed when this link is being followed, e.g the name of a function. + // Must be contained by the `targetRange`. See also `DocumentSymbol#range` + TargetSelectionRange Range `json:"targetSelectionRange"` +} + +// The log message parameters. +type LogMessageParams struct { // line 4251 + // The message type. See {@link MessageType} + Type MessageType `json:"type"` + // The actual message. + Message string `json:"message"` +} +type LogTraceParams struct { // line 6159 + Message string `json:"message"` + Verbose string `json:"verbose,omitempty"` +} + +// Client capabilities specific to the used markdown parser. +// +// @since 3.16.0 +type MarkdownClientCapabilities struct { // line 12524 + // The name of the parser. + Parser string `json:"parser"` + // The version of the parser. + Version string `json:"version,omitempty"` + // A list of HTML tags that the client allows / supports in + // Markdown. + // + // @since 3.17.0 + AllowedTags []string `json:"allowedTags,omitempty"` +} + +// MarkedString can be used to render human readable text. It is either a markdown string +// or a code-block that provides a language and a code snippet. The language identifier +// is semantically equal to the optional language identifier in fenced code blocks in GitHub +// issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting +// +// The pair of a language and a value is an equivalent to markdown: +// ```${language} +// ${value} +// ``` +// +// Note that markdown strings will be sanitized - that means html will be escaped. +// @deprecated use MarkupContent instead. +type MarkedString = Or_MarkedString // (alias) line 14058 +// A `MarkupContent` literal represents a string value which content is interpreted base on its +// kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds. +// +// If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues. +// See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting +// +// Here is an example how such a string can be constructed using JavaScript / TypeScript: +// ```ts +// +// let markdown: MarkdownContent = { +// kind: MarkupKind.Markdown, +// value: [ +// '# Header', +// 'Some text', +// '```typescript', +// 'someCode();', +// '```' +// ].join('\n') +// }; +// +// ``` +// +// *Please Note* that clients might sanitize the return markdown. A client could decide to +// remove HTML from the markdown to avoid script execution. +type MarkupContent struct { // line 7113 + // The type of the Markup + Kind MarkupKind `json:"kind"` + // The content itself + Value string `json:"value"` +} + +// Describes the content type that a client supports in various +// result literals like `Hover`, `ParameterInfo` or `CompletionItem`. +// +// Please note that `MarkupKinds` must not start with a `$`. This kinds +// are reserved for internal usage. +type MarkupKind string // line 13407 +type MessageActionItem struct { // line 4238 + // A short title like 'Retry', 'Open Log' etc. + Title string `json:"title"` +} + +// The message type +type MessageType uint32 // line 13054 +// Moniker definition to match LSIF 0.5 moniker definition. +// +// @since 3.16.0 +type Moniker struct { // line 3338 + // The scheme of the moniker. For example tsc or .Net + Scheme string `json:"scheme"` + // The identifier of the moniker. The value is opaque in LSIF however + // schema owners are allowed to define the structure if they want. + Identifier string `json:"identifier"` + // The scope in which the moniker is unique + Unique UniquenessLevel `json:"unique"` + // The moniker kind if known. + Kind *MonikerKind `json:"kind,omitempty"` +} + +// Client capabilities specific to the moniker request. +// +// @since 3.16.0 +type MonikerClientCapabilities struct { // line 12321 + // Whether moniker supports dynamic registration. If this is set to `true` + // the client supports the new `MonikerRegistrationOptions` return value + // for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// The moniker kind. +// +// @since 3.16.0 +type MonikerKind string // line 13007 +type MonikerOptions struct { // line 6926 + WorkDoneProgressOptions +} +type MonikerParams struct { // line 3318 + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} +type MonikerRegistrationOptions struct { // line 3378 + TextDocumentRegistrationOptions + MonikerOptions +} + +// created for Literal (Lit_MarkedString_Item1) +type Msg_MarkedString struct { // line 14068 + Language string `json:"language"` + Value string `json:"value"` +} + +// created for Literal (Lit_NotebookDocumentFilter_Item0) +type Msg_NotebookDocumentFilter struct { // line 14260 + // The type of the enclosing notebook. + NotebookType string `json:"notebookType"` + // A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. + Scheme string `json:"scheme,omitempty"` + // A glob pattern. + Pattern string `json:"pattern,omitempty"` +} + +// created for Literal (Lit_PrepareRenameResult_Item1) +type Msg_PrepareRename2Gn struct { // line 13911 + Range Range `json:"range"` + Placeholder string `json:"placeholder"` +} + +// created for Literal (Lit_TextDocumentContentChangeEvent_Item0) +type Msg_TextDocumentContentChangeEvent struct { // line 14008 + // The range of the document that changed. + Range *Range `json:"range"` + // The optional length of the range that got replaced. + // + // @deprecated use range instead. + RangeLength uint32 `json:"rangeLength,omitempty"` + // The new text for the provided range. + Text string `json:"text"` +} + +// created for Literal (Lit_TextDocumentFilter_Item1) +type Msg_TextDocumentFilter struct { // line 14184 + // A language id, like `typescript`. + Language string `json:"language,omitempty"` + // A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. + Scheme string `json:"scheme"` + // A glob pattern, like `*.{ts,js}`. + Pattern string `json:"pattern,omitempty"` +} + +// created for Literal (Lit__InitializeParams_clientInfo) +type Msg_XInitializeParams_clientInfo struct { // line 7673 + // The name of the client as defined by the client. + Name string `json:"name"` + // The client's version as defined by the client. + Version string `json:"version,omitempty"` +} + +// A notebook cell. +// +// A cell's document URI must be unique across ALL notebook +// cells and can therefore be used to uniquely identify a +// notebook cell or the cell's text document. +// +// @since 3.17.0 +type NotebookCell struct { // line 9598 + // The cell's kind + Kind NotebookCellKind `json:"kind"` + // The URI of the cell's text document + // content. + Document DocumentURI `json:"document"` + // Additional metadata stored with the cell. + // + // Note: should always be an object literal (e.g. LSPObject) + Metadata *LSPObject `json:"metadata,omitempty"` + // Additional execution summary information + // if supported by the client. + ExecutionSummary *ExecutionSummary `json:"executionSummary,omitempty"` +} + +// A change describing how to move a `NotebookCell` +// array from state S to S'. +// +// @since 3.17.0 +type NotebookCellArrayChange struct { // line 9639 + // The start oftest of the cell that changed. + Start uint32 `json:"start"` + // The deleted cells + DeleteCount uint32 `json:"deleteCount"` + // The new cells, if any + Cells []NotebookCell `json:"cells,omitempty"` +} + +// A notebook cell kind. +// +// @since 3.17.0 +type NotebookCellKind uint32 // line 13648 +// A notebook cell text document filter denotes a cell text +// document by different properties. +// +// @since 3.17.0 +type NotebookCellTextDocumentFilter struct { // line 10113 + // A filter that matches against the notebook + // containing the notebook cell. If a string + // value is provided it matches against the + // notebook type. '*' matches every notebook. + Notebook Or_NotebookCellTextDocumentFilter_notebook `json:"notebook"` + // A language id like `python`. + // + // Will be matched against the language id of the + // notebook cell document. '*' matches every language. + Language string `json:"language,omitempty"` +} + +// A notebook document. +// +// @since 3.17.0 +type NotebookDocument struct { // line 7354 + // The notebook document's uri. + URI URI `json:"uri"` + // The type of the notebook. + NotebookType string `json:"notebookType"` + // The version number of this document (it will increase after each + // change, including undo/redo). + Version int32 `json:"version"` + // Additional metadata stored with the notebook + // document. + // + // Note: should always be an object literal (e.g. LSPObject) + Metadata *LSPObject `json:"metadata,omitempty"` + // The cells of a notebook. + Cells []NotebookCell `json:"cells"` +} + +// A change event for a notebook document. +// +// @since 3.17.0 +type NotebookDocumentChangeEvent struct { // line 7466 + // The changed meta data if any. + // + // Note: should always be an object literal (e.g. LSPObject) + Metadata *LSPObject `json:"metadata,omitempty"` + // Changes to cells + Cells *PCellsPChange `json:"cells,omitempty"` +} + +// Capabilities specific to the notebook document support. +// +// @since 3.17.0 +type NotebookDocumentClientCapabilities struct { // line 10613 + // Capabilities specific to notebook document synchronization + // + // @since 3.17.0 + Synchronization NotebookDocumentSyncClientCapabilities `json:"synchronization"` +} + +// A notebook document filter denotes a notebook document by +// different properties. The properties will be match +// against the notebook's URI (same as with documents) +// +// @since 3.17.0 +type NotebookDocumentFilter = Msg_NotebookDocumentFilter // (alias) line 14254 +// A literal to identify a notebook document in the client. +// +// @since 3.17.0 +type NotebookDocumentIdentifier struct { // line 7582 + // The notebook document's uri. + URI URI `json:"uri"` +} + +// Notebook specific client capabilities. +// +// @since 3.17.0 +type NotebookDocumentSyncClientCapabilities struct { // line 12433 + // Whether implementation supports dynamic registration. If this is + // set to `true` the client supports the new + // `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + // return value for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports sending execution summary data per cell. + ExecutionSummarySupport bool `json:"executionSummarySupport,omitempty"` +} + +// Options specific to a notebook plus its cells +// to be synced to the server. +// +// If a selector provides a notebook document +// filter but no cell selector all cells of a +// matching notebook document will be synced. +// +// If a selector provides no notebook document +// filter but only a cell selector all notebook +// document that contain at least one matching +// cell will be synced. +// +// @since 3.17.0 +type NotebookDocumentSyncOptions struct { // line 9795 + // The notebooks to be synced + NotebookSelector []PNotebookSelectorPNotebookDocumentSync `json:"notebookSelector"` + // Whether save notification should be forwarded to + // the server. Will only be honored if mode === `notebook`. + Save bool `json:"save,omitempty"` +} + +// Registration options specific to a notebook. +// +// @since 3.17.0 +type NotebookDocumentSyncRegistrationOptions struct { // line 9915 + NotebookDocumentSyncOptions + StaticRegistrationOptions +} + +// A text document identifier to optionally denote a specific version of a text document. +type OptionalVersionedTextDocumentIdentifier struct { // line 9343 + // The version number of this document. If a versioned text document identifier + // is sent from the server to the client and the file is not open in the editor + // (the server has not received an open notification before) the server can send + // `null` to indicate that the version is unknown and the content on disk is the + // truth (as specified with document content ownership). + Version int32 `json:"version"` + TextDocumentIdentifier +} + +// created for Or [FEditRangePItemDefaults Range] +type OrFEditRangePItemDefaults struct { // line 4770 + Value interface{} `json:"value"` +} + +// created for Or [NotebookDocumentFilter string] +type OrFNotebookPNotebookSelector struct { // line 9812 + Value interface{} `json:"value"` +} + +// created for Or [Location PLocationMsg_workspace_symbol] +type OrPLocation_workspace_symbol struct { // line 5521 + Value interface{} `json:"value"` +} + +// created for Or [[]string string] +type OrPSection_workspace_didChangeConfiguration struct { // line 4164 + Value interface{} `json:"value"` +} + +// created for Or [MarkupContent string] +type OrPTooltipPLabel struct { // line 7076 + Value interface{} `json:"value"` +} + +// created for Or [MarkupContent string] +type OrPTooltip_textDocument_inlayHint struct { // line 3700 + Value interface{} `json:"value"` +} + +// created for Or [int32 string] +type Or_CancelParams_id struct { // line 6185 + Value interface{} `json:"value"` +} + +// created for Or [MarkupContent string] +type Or_CompletionItem_documentation struct { // line 4583 + Value interface{} `json:"value"` +} + +// created for Or [InsertReplaceEdit TextEdit] +type Or_CompletionItem_textEdit struct { // line 4666 + Value interface{} `json:"value"` +} + +// created for Or [Location []Location] +type Or_Definition struct { // line 13754 + Value interface{} `json:"value"` +} + +// created for Or [int32 string] +type Or_Diagnostic_code struct { // line 8548 + Value interface{} `json:"value"` +} + +// created for Or [RelatedFullDocumentDiagnosticReport RelatedUnchangedDocumentDiagnosticReport] +type Or_DocumentDiagnosticReport struct { // line 13886 + Value interface{} `json:"value"` +} + +// created for Or [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport] +type Or_DocumentDiagnosticReportPartialResult_relatedDocuments_Value struct { // line 3823 + Value interface{} `json:"value"` +} + +// created for Or [NotebookCellTextDocumentFilter TextDocumentFilter] +type Or_DocumentFilter struct { // line 14096 + Value interface{} `json:"value"` +} + +// created for Or [MarkedString MarkupContent []MarkedString] +type Or_Hover_contents struct { // line 4892 + Value interface{} `json:"value"` +} + +// created for Or [[]InlayHintLabelPart string] +type Or_InlayHint_label struct { // line 3659 + Value interface{} `json:"value"` +} + +// created for Or [InlineValueEvaluatableExpression InlineValueText InlineValueVariableLookup] +type Or_InlineValue struct { // line 13864 + Value interface{} `json:"value"` +} + +// created for Or [Msg_MarkedString string] +type Or_MarkedString struct { // line 14061 + Value interface{} `json:"value"` +} + +// created for Or [NotebookDocumentFilter string] +type Or_NotebookCellTextDocumentFilter_notebook struct { // line 10119 + Value interface{} `json:"value"` +} + +// created for Or [NotebookDocumentFilter string] +type Or_NotebookDocumentSyncOptions_notebookSelector_Elem_Item1_notebook struct { // line 9858 + Value interface{} `json:"value"` +} + +// created for Or [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport] +type Or_RelatedFullDocumentDiagnosticReport_relatedDocuments_Value struct { // line 7169 + Value interface{} `json:"value"` +} + +// created for Or [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport] +type Or_RelatedUnchangedDocumentDiagnosticReport_relatedDocuments_Value struct { // line 7208 + Value interface{} `json:"value"` +} + +// created for Or [URI WorkspaceFolder] +type Or_RelativePattern_baseUri struct { // line 10742 + Value interface{} `json:"value"` +} + +// created for Or [CodeAction Command] +type Or_Result_textDocument_codeAction_Item0_Elem struct { // line 1372 + Value interface{} `json:"value"` +} + +// created for Or [FFullPRequests bool] +type Or_SemanticTokensClientCapabilities_requests_full struct { // line 12198 + Value interface{} `json:"value"` +} + +// created for Or [FRangePRequests bool] +type Or_SemanticTokensClientCapabilities_requests_range struct { // line 12178 + Value interface{} `json:"value"` +} + +// created for Or [PFullESemanticTokensOptions bool] +type Or_SemanticTokensOptions_full struct { // line 6580 + Value interface{} `json:"value"` +} + +// created for Or [PRangeESemanticTokensOptions bool] +type Or_SemanticTokensOptions_range struct { // line 6560 + Value interface{} `json:"value"` +} + +// created for Or [CallHierarchyOptions CallHierarchyRegistrationOptions bool] +type Or_ServerCapabilities_callHierarchyProvider struct { // line 8228 + Value interface{} `json:"value"` +} + +// created for Or [CodeActionOptions bool] +type Or_ServerCapabilities_codeActionProvider struct { // line 8036 + Value interface{} `json:"value"` +} + +// created for Or [DocumentColorOptions DocumentColorRegistrationOptions bool] +type Or_ServerCapabilities_colorProvider struct { // line 8072 + Value interface{} `json:"value"` +} + +// created for Or [DeclarationOptions DeclarationRegistrationOptions bool] +type Or_ServerCapabilities_declarationProvider struct { // line 7898 + Value interface{} `json:"value"` +} + +// created for Or [DefinitionOptions bool] +type Or_ServerCapabilities_definitionProvider struct { // line 7920 + Value interface{} `json:"value"` +} + +// created for Or [DiagnosticOptions DiagnosticRegistrationOptions] +type Or_ServerCapabilities_diagnosticProvider struct { // line 8385 + Value interface{} `json:"value"` +} + +// created for Or [DocumentFormattingOptions bool] +type Or_ServerCapabilities_documentFormattingProvider struct { // line 8112 + Value interface{} `json:"value"` +} + +// created for Or [DocumentHighlightOptions bool] +type Or_ServerCapabilities_documentHighlightProvider struct { // line 8000 + Value interface{} `json:"value"` +} + +// created for Or [DocumentRangeFormattingOptions bool] +type Or_ServerCapabilities_documentRangeFormattingProvider struct { // line 8130 + Value interface{} `json:"value"` +} + +// created for Or [DocumentSymbolOptions bool] +type Or_ServerCapabilities_documentSymbolProvider struct { // line 8018 + Value interface{} `json:"value"` +} + +// created for Or [FoldingRangeOptions FoldingRangeRegistrationOptions bool] +type Or_ServerCapabilities_foldingRangeProvider struct { // line 8175 + Value interface{} `json:"value"` +} + +// created for Or [HoverOptions bool] +type Or_ServerCapabilities_hoverProvider struct { // line 7871 + Value interface{} `json:"value"` +} + +// created for Or [ImplementationOptions ImplementationRegistrationOptions bool] +type Or_ServerCapabilities_implementationProvider struct { // line 7960 + Value interface{} `json:"value"` +} + +// created for Or [InlayHintOptions InlayHintRegistrationOptions bool] +type Or_ServerCapabilities_inlayHintProvider struct { // line 8362 + Value interface{} `json:"value"` +} + +// created for Or [InlineValueOptions InlineValueRegistrationOptions bool] +type Or_ServerCapabilities_inlineValueProvider struct { // line 8339 + Value interface{} `json:"value"` +} + +// created for Or [LinkedEditingRangeOptions LinkedEditingRangeRegistrationOptions bool] +type Or_ServerCapabilities_linkedEditingRangeProvider struct { // line 8251 + Value interface{} `json:"value"` +} + +// created for Or [MonikerOptions MonikerRegistrationOptions bool] +type Or_ServerCapabilities_monikerProvider struct { // line 8293 + Value interface{} `json:"value"` +} + +// created for Or [NotebookDocumentSyncOptions NotebookDocumentSyncRegistrationOptions] +type Or_ServerCapabilities_notebookDocumentSync struct { // line 7843 + Value interface{} `json:"value"` +} + +// created for Or [ReferenceOptions bool] +type Or_ServerCapabilities_referencesProvider struct { // line 7982 + Value interface{} `json:"value"` +} + +// created for Or [RenameOptions bool] +type Or_ServerCapabilities_renameProvider struct { // line 8157 + Value interface{} `json:"value"` +} + +// created for Or [SelectionRangeOptions SelectionRangeRegistrationOptions bool] +type Or_ServerCapabilities_selectionRangeProvider struct { // line 8197 + Value interface{} `json:"value"` +} + +// created for Or [SemanticTokensOptions SemanticTokensRegistrationOptions] +type Or_ServerCapabilities_semanticTokensProvider struct { // line 8274 + Value interface{} `json:"value"` +} + +// created for Or [TextDocumentSyncKind TextDocumentSyncOptions] +type Or_ServerCapabilities_textDocumentSync struct { // line 7825 + Value interface{} `json:"value"` +} + +// created for Or [TypeDefinitionOptions TypeDefinitionRegistrationOptions bool] +type Or_ServerCapabilities_typeDefinitionProvider struct { // line 7938 + Value interface{} `json:"value"` +} + +// created for Or [TypeHierarchyOptions TypeHierarchyRegistrationOptions bool] +type Or_ServerCapabilities_typeHierarchyProvider struct { // line 8316 + Value interface{} `json:"value"` +} + +// created for Or [WorkspaceSymbolOptions bool] +type Or_ServerCapabilities_workspaceSymbolProvider struct { // line 8094 + Value interface{} `json:"value"` +} + +// created for Or [MarkupContent string] +type Or_SignatureInformation_documentation struct { // line 8842 + Value interface{} `json:"value"` +} + +// created for Or [AnnotatedTextEdit TextEdit] +type Or_TextDocumentEdit_edits_Elem struct { // line 6693 + Value interface{} `json:"value"` +} + +// created for Or [SaveOptions bool] +type Or_TextDocumentSyncOptions_save struct { // line 9778 + Value interface{} `json:"value"` +} + +// created for Or [WorkspaceFullDocumentDiagnosticReport WorkspaceUnchangedDocumentDiagnosticReport] +type Or_WorkspaceDocumentDiagnosticReport struct { // line 13987 + Value interface{} `json:"value"` +} + +// created for Or [CreateFile DeleteFile RenameFile TextDocumentEdit] +type Or_WorkspaceEdit_documentChanges_Elem struct { // line 3220 + Value interface{} `json:"value"` +} + +// created for Or [Declaration []DeclarationLink] +type Or_textDocument_declaration struct { // line 249 + Value interface{} `json:"value"` +} + +// created for Literal (Lit_NotebookDocumentChangeEvent_cells) +type PCellsPChange struct { // line 7481 + // Changes to the cell structure to add or + // remove cells. + Structure *FStructurePCells `json:"structure,omitempty"` + // Changes to notebook cells properties like its + // kind, execution summary or metadata. + Data []NotebookCell `json:"data,omitempty"` + // Changes to the text content of notebook cells. + TextContent []Lit_NotebookDocumentChangeEvent_cells_textContent_Elem `json:"textContent,omitempty"` +} + +// created for Literal (Lit_WorkspaceEditClientCapabilities_changeAnnotationSupport) +type PChangeAnnotationSupportPWorkspaceEdit struct { // line 10816 + // Whether the client groups edits with equal labels into tree nodes, + // for instance all edits labelled with "Changes in Strings" would + // be a tree node. + GroupsOnLabel bool `json:"groupsOnLabel,omitempty"` +} + +// created for Literal (Lit_CodeActionClientCapabilities_codeActionLiteralSupport) +type PCodeActionLiteralSupportPCodeAction struct { // line 11736 + // The code action kind is support with the following value + // set. + CodeActionKind FCodeActionKindPCodeActionLiteralSupport `json:"codeActionKind"` +} + +// created for Literal (Lit_CompletionClientCapabilities_completionItemKind) +type PCompletionItemKindPCompletion struct { // line 11334 + // The completion item kind values the client supports. When this + // property exists the client also guarantees that it will + // handle values outside its set gracefully and falls back + // to a default value when unknown. + // + // If this property is not present the client only supports + // the completion items kinds from `Text` to `Reference` as defined in + // the initial version of the protocol. + ValueSet []CompletionItemKind `json:"valueSet,omitempty"` +} + +// created for Literal (Lit_CompletionClientCapabilities_completionItem) +type PCompletionItemPCompletion struct { // line 11183 + // Client supports snippets as insert text. + // + // A snippet can define tab stops and placeholders with `$1`, `$2` + // and `${3:foo}`. `$0` defines the final tab stop, it defaults to + // the end of the snippet. Placeholders with equal identifiers are linked, + // that is typing in one will update others too. + SnippetSupport bool `json:"snippetSupport,omitempty"` + // Client supports commit characters on a completion item. + CommitCharactersSupport bool `json:"commitCharactersSupport,omitempty"` + // Client supports the following content formats for the documentation + // property. The order describes the preferred format of the client. + DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"` + // Client supports the deprecated property on a completion item. + DeprecatedSupport bool `json:"deprecatedSupport,omitempty"` + // Client supports the preselect property on a completion item. + PreselectSupport bool `json:"preselectSupport,omitempty"` + // Client supports the tag property on a completion item. Clients supporting + // tags have to handle unknown tags gracefully. Clients especially need to + // preserve unknown tags when sending a completion item back to the server in + // a resolve call. + // + // @since 3.15.0 + TagSupport FTagSupportPCompletionItem `json:"tagSupport"` + // Client support insert replace edit to control different behavior if a + // completion item is inserted in the text or should replace text. + // + // @since 3.16.0 + InsertReplaceSupport bool `json:"insertReplaceSupport,omitempty"` + // Indicates which properties a client can resolve lazily on a completion + // item. Before version 3.16.0 only the predefined properties `documentation` + // and `details` could be resolved lazily. + // + // @since 3.16.0 + ResolveSupport *FResolveSupportPCompletionItem `json:"resolveSupport,omitempty"` + // The client supports the `insertTextMode` property on + // a completion item to override the whitespace handling mode + // as defined by the client (see `insertTextMode`). + // + // @since 3.16.0 + InsertTextModeSupport *FInsertTextModeSupportPCompletionItem `json:"insertTextModeSupport,omitempty"` + // The client has support for completion item label + // details (see also `CompletionItemLabelDetails`). + // + // @since 3.17.0 + LabelDetailsSupport bool `json:"labelDetailsSupport,omitempty"` +} + +// created for Literal (Lit_CompletionOptions_completionItem) +type PCompletionItemPCompletionProvider struct { // line 8747 + // The server has support for completion item label + // details (see also `CompletionItemLabelDetails`) when + // receiving a completion item in a resolve call. + // + // @since 3.17.0 + LabelDetailsSupport bool `json:"labelDetailsSupport,omitempty"` +} + +// created for Literal (Lit_CompletionClientCapabilities_completionList) +type PCompletionListPCompletion struct { // line 11376 + // The client supports the following itemDefaults on + // a completion list. + // + // The value lists the supported property names of the + // `CompletionList.itemDefaults` object. If omitted + // no properties are supported. + // + // @since 3.17.0 + ItemDefaults []string `json:"itemDefaults,omitempty"` +} + +// created for Literal (Lit_CodeAction_disabled) +type PDisabledMsg_textDocument_codeAction struct { // line 5427 + // Human readable description of why the code action is currently disabled. + // + // This is displayed in the code actions UI. + Reason string `json:"reason"` +} + +// created for Literal (Lit_FoldingRangeClientCapabilities_foldingRangeKind) +type PFoldingRangeKindPFoldingRange struct { // line 12011 + // The folding range kind values the client supports. When this + // property exists the client also guarantees that it will + // handle values outside its set gracefully and falls back + // to a default value when unknown. + ValueSet []FoldingRangeKind `json:"valueSet,omitempty"` +} + +// created for Literal (Lit_FoldingRangeClientCapabilities_foldingRange) +type PFoldingRangePFoldingRange struct { // line 12036 + // If set, the client signals that it supports setting collapsedText on + // folding ranges to display custom labels instead of the default text. + // + // @since 3.17.0 + CollapsedText bool `json:"collapsedText,omitempty"` +} + +// created for Literal (Lit_SemanticTokensOptions_full_Item1) +type PFullESemanticTokensOptions struct { // line 6587 + // The server supports deltas for full documents. + Delta bool `json:"delta"` +} + +// created for Literal (Lit_CompletionList_itemDefaults) +type PItemDefaultsMsg_textDocument_completion struct { // line 4751 + // A default commit character set. + // + // @since 3.17.0 + CommitCharacters []string `json:"commitCharacters,omitempty"` + // A default edit range. + // + // @since 3.17.0 + EditRange *OrFEditRangePItemDefaults `json:"editRange,omitempty"` + // A default insert text format. + // + // @since 3.17.0 + InsertTextFormat *InsertTextFormat `json:"insertTextFormat,omitempty"` + // A default insert text mode. + // + // @since 3.17.0 + InsertTextMode *InsertTextMode `json:"insertTextMode,omitempty"` + // A default data value. + // + // @since 3.17.0 + Data interface{} `json:"data,omitempty"` +} + +// created for Literal (Lit_WorkspaceSymbol_location_Item1) +type PLocationMsg_workspace_symbol struct { // line 5528 + URI DocumentURI `json:"uri"` +} + +// created for Literal (Lit_ShowMessageRequestClientCapabilities_messageActionItem) +type PMessageActionItemPShowMessage struct { // line 12464 + // Whether the client supports additional attributes which + // are preserved and send back to the server in the + // request's response. + AdditionalPropertiesSupport bool `json:"additionalPropertiesSupport,omitempty"` +} + +// created for Literal (Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item0) +type PNotebookSelectorPNotebookDocumentSync struct { // line 9806 + // The notebook to be synced If a string + // value is provided it matches against the + // notebook type. '*' matches every notebook. + Notebook OrFNotebookPNotebookSelector `json:"notebook"` + // The cells of the matching notebook to be synced. + Cells []Lit_NotebookDocumentSyncOptions_notebookSelector_Elem_Item0_cells_Elem `json:"cells,omitempty"` +} + +// created for Literal (Lit_SemanticTokensOptions_range_Item1) +type PRangeESemanticTokensOptions struct { // line 6567 +} + +// created for Literal (Lit_SemanticTokensClientCapabilities_requests) +type PRequestsPSemanticTokens struct { // line 12172 + // The client will send the `textDocument/semanticTokens/range` request if + // the server provides a corresponding handler. + Range Or_SemanticTokensClientCapabilities_requests_range `json:"range"` + // The client will send the `textDocument/semanticTokens/full` request if + // the server provides a corresponding handler. + Full Or_SemanticTokensClientCapabilities_requests_full `json:"full"` +} + +// created for Literal (Lit_CodeActionClientCapabilities_resolveSupport) +type PResolveSupportPCodeAction struct { // line 11801 + // The properties that a client can resolve lazily. + Properties []string `json:"properties"` +} + +// created for Literal (Lit_InlayHintClientCapabilities_resolveSupport) +type PResolveSupportPInlayHint struct { // line 12384 + // The properties that a client can resolve lazily. + Properties []string `json:"properties"` +} + +// created for Literal (Lit_WorkspaceSymbolClientCapabilities_resolveSupport) +type PResolveSupportPSymbol struct { // line 10938 + // The properties that a client can resolve lazily. Usually + // `location.range` + Properties []string `json:"properties"` +} + +// created for Literal (Lit_InitializeResult_serverInfo) +type PServerInfoMsg_initialize struct { // line 4096 + // The name of the server as defined by the server. + Name string `json:"name"` + // The server's version as defined by the server. + Version string `json:"version,omitempty"` +} + +// created for Literal (Lit_SignatureHelpClientCapabilities_signatureInformation) +type PSignatureInformationPSignatureHelp struct { // line 11443 + // Client supports the following content formats for the documentation + // property. The order describes the preferred format of the client. + DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"` + // Client capabilities specific to parameter information. + ParameterInformation *FParameterInformationPSignatureInformation `json:"parameterInformation,omitempty"` + // The client supports the `activeParameter` property on `SignatureInformation` + // literal. + // + // @since 3.16.0 + ActiveParameterSupport bool `json:"activeParameterSupport,omitempty"` +} + +// created for Literal (Lit_GeneralClientCapabilities_staleRequestSupport) +type PStaleRequestSupportPGeneral struct { // line 10670 + // The client will actively cancel the request. + Cancel bool `json:"cancel"` + // The list of requests for which the client + // will retry the request if it receives a + // response with error code `ContentModified` + RetryOnContentModified []string `json:"retryOnContentModified"` +} + +// created for Literal (Lit_DocumentSymbolClientCapabilities_symbolKind) +type PSymbolKindPDocumentSymbol struct { // line 11654 + // The symbol kind values the client supports. When this + // property exists the client also guarantees that it will + // handle values outside its set gracefully and falls back + // to a default value when unknown. + // + // If this property is not present the client only supports + // the symbol kinds from `File` to `Array` as defined in + // the initial version of the protocol. + ValueSet []SymbolKind `json:"valueSet,omitempty"` +} + +// created for Literal (Lit_WorkspaceSymbolClientCapabilities_symbolKind) +type PSymbolKindPSymbol struct { // line 10890 + // The symbol kind values the client supports. When this + // property exists the client also guarantees that it will + // handle values outside its set gracefully and falls back + // to a default value when unknown. + // + // If this property is not present the client only supports + // the symbol kinds from `File` to `Array` as defined in + // the initial version of the protocol. + ValueSet []SymbolKind `json:"valueSet,omitempty"` +} + +// created for Literal (Lit_DocumentSymbolClientCapabilities_tagSupport) +type PTagSupportPDocumentSymbol struct { // line 11687 + // The tags supported by the client. + ValueSet []SymbolTag `json:"valueSet"` +} + +// created for Literal (Lit_PublishDiagnosticsClientCapabilities_tagSupport) +type PTagSupportPPublishDiagnostics struct { // line 12087 + // The tags supported by the client. + ValueSet []DiagnosticTag `json:"valueSet"` +} + +// created for Literal (Lit_WorkspaceSymbolClientCapabilities_tagSupport) +type PTagSupportPSymbol struct { // line 10914 + // The tags supported by the client. + ValueSet []SymbolTag `json:"valueSet"` +} + +// The parameters of a configuration request. +type ParamConfiguration struct { // line 2199 + Items []ConfigurationItem `json:"items"` +} +type ParamInitialize struct { // line 4068 + XInitializeParams + WorkspaceFoldersInitializeParams +} + +// Represents a parameter of a callable-signature. A parameter can +// have a label and a doc-comment. +type ParameterInformation struct { // line 10063 + // The label of this parameter information. + // + // Either a string or an inclusive start and exclusive end offsets within its containing + // signature label. (see SignatureInformation.label). The offsets are based on a UTF-16 + // string representation as `Position` and `Range` does. + // + // *Note*: a label of type string should be a substring of its containing signature label. + // Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`. + Label string `json:"label"` + // The human-readable doc-comment of this parameter. Will be shown + // in the UI but can be omitted. + Documentation string `json:"documentation,omitempty"` +} +type PartialResultParams struct { // line 6258 + // An optional token that a server can use to report partial results (e.g. streaming) to + // the client. + PartialResultToken *ProgressToken `json:"partialResultToken,omitempty"` +} + +// The glob pattern to watch relative to the base path. Glob patterns can have the following syntax: +// +// - `*` to match one or more characters in a path segment +// - `?` to match on one character in a path segment +// - `**` to match any number of path segments, including none +// - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files) +// - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) +// - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) +// +// @since 3.17.0 +type Pattern = string // (alias) line 14363 +// Position in a text document expressed as zero-based line and character +// offset. Prior to 3.17 the offsets were always based on a UTF-16 string +// representation. So a string of the form `a𐐀b` the character offset of the +// character `a` is 0, the character offset of `𐐀` is 1 and the character +// offset of b is 3 since `𐐀` is represented using two code units in UTF-16. +// Since 3.17 clients and servers can agree on a different string encoding +// representation (e.g. UTF-8). The client announces it's supported encoding +// via the client capability [`general.positionEncodings`](#clientCapabilities). +// The value is an array of position encodings the client supports, with +// decreasing preference (e.g. the encoding at index `0` is the most preferred +// one). To stay backwards compatible the only mandatory encoding is UTF-16 +// represented via the string `utf-16`. The server can pick one of the +// encodings offered by the client and signals that encoding back to the +// client via the initialize result's property +// [`capabilities.positionEncoding`](#serverCapabilities). If the string value +// `utf-16` is missing from the client's capability `general.positionEncodings` +// servers can safely assume that the client supports UTF-16. If the server +// omits the position encoding in its initialize result the encoding defaults +// to the string value `utf-16`. Implementation considerations: since the +// conversion from one encoding into another requires the content of the +// file / line the conversion is best done where the file is read which is +// usually on the server side. +// +// Positions are line end character agnostic. So you can not specify a position +// that denotes `\r|\n` or `\n|` where `|` represents the character offset. +// +// @since 3.17.0 - support for negotiated position encoding. +type Position struct { // line 6501 + // Line position in a document (zero-based). + // + // If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document. + // If a line number is negative, it defaults to 0. + Line uint32 `json:"line"` + // Character offset on a line in a document (zero-based). + // + // The meaning of this offset is determined by the negotiated + // `PositionEncodingKind`. + // + // If the character value is greater than the line length it defaults back to the + // line length. + Character uint32 `json:"character"` +} + +// A set of predefined position encoding kinds. +// +// @since 3.17.0 +type PositionEncodingKind string // line 13427 +type PrepareRename2Gn = Msg_PrepareRename2Gn // (alias) line 13927 +type PrepareRenameParams struct { // line 5925 + TextDocumentPositionParams + WorkDoneProgressParams +} +type PrepareRenameResult = Msg_PrepareRename2Gn // (alias) line 13927 +type PrepareSupportDefaultBehavior uint32 // line 13722 +// A previous result id in a workspace pull request. +// +// @since 3.17.0 +type PreviousResultID struct { // line 7331 + // The URI for which the client knowns a + // result id. + URI DocumentURI `json:"uri"` + // The value of the previous result id. + Value string `json:"value"` +} + +// A previous result id in a workspace pull request. +// +// @since 3.17.0 +type PreviousResultId struct { // line 7331 + // The URI for which the client knowns a + // result id. + URI DocumentURI `json:"uri"` + // The value of the previous result id. + Value string `json:"value"` +} +type ProgressParams struct { // line 6201 + // The progress token provided by the client or server. + Token ProgressToken `json:"token"` + // The progress data. + Value interface{} `json:"value"` +} +type ProgressToken = interface{} // (alias) line 13960 +// The publish diagnostic client capabilities. +type PublishDiagnosticsClientCapabilities struct { // line 12072 + // Whether the clients accepts diagnostics with related information. + RelatedInformation bool `json:"relatedInformation,omitempty"` + // Client supports the tag property to provide meta data about a diagnostic. + // Clients supporting tags have to handle unknown tags gracefully. + // + // @since 3.15.0 + TagSupport *PTagSupportPPublishDiagnostics `json:"tagSupport,omitempty"` + // Whether the client interprets the version property of the + // `textDocument/publishDiagnostics` notification's parameter. + // + // @since 3.15.0 + VersionSupport bool `json:"versionSupport,omitempty"` + // Client supports a codeDescription property + // + // @since 3.16.0 + CodeDescriptionSupport bool `json:"codeDescriptionSupport,omitempty"` + // Whether code action supports the `data` property which is + // preserved between a `textDocument/publishDiagnostics` and + // `textDocument/codeAction` request. + // + // @since 3.16.0 + DataSupport bool `json:"dataSupport,omitempty"` +} + +// The publish diagnostic notification's parameters. +type PublishDiagnosticsParams struct { // line 4462 + // The URI for which diagnostic information is reported. + URI DocumentURI `json:"uri"` + // Optional the version number of the document the diagnostics are published for. + // + // @since 3.15.0 + Version int32 `json:"version,omitempty"` + // An array of diagnostic information items. + Diagnostics []Diagnostic `json:"diagnostics"` +} + +// A range in a text document expressed as (zero-based) start and end positions. +// +// If you want to specify a range that contains a line including the line ending +// character(s) then use an end position denoting the start of the next line. +// For example: +// ```ts +// +// { +// start: { line: 5, character: 23 } +// end : { line 6, character : 0 } +// } +// +// ``` +type Range struct { // line 6311 + // The range's start position. + Start Position `json:"start"` + // The range's end position. + End Position `json:"end"` +} + +// Client Capabilities for a {@link ReferencesRequest}. +type ReferenceClientCapabilities struct { // line 11609 + // Whether references supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// Value-object that contains additional information when +// requesting references. +type ReferenceContext struct { // line 8930 + // Include the declaration of the current symbol. + IncludeDeclaration bool `json:"includeDeclaration"` +} + +// Reference options. +type ReferenceOptions struct { // line 8944 + WorkDoneProgressOptions +} + +// Parameters for a {@link ReferencesRequest}. +type ReferenceParams struct { // line 5054 + Context ReferenceContext `json:"context"` + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link ReferencesRequest}. +type ReferenceRegistrationOptions struct { // line 5083 + TextDocumentRegistrationOptions + ReferenceOptions +} + +// General parameters to to register for an notification or to register a provider. +type Registration struct { // line 7597 + // The id used to register the request. The id can be used to deregister + // the request again. + ID string `json:"id"` + // The method / capability to register for. + Method string `json:"method"` + // Options necessary for the registration. + RegisterOptions interface{} `json:"registerOptions,omitempty"` +} +type RegistrationParams struct { // line 4038 + Registrations []Registration `json:"registrations"` +} + +// Client capabilities specific to regular expressions. +// +// @since 3.16.0 +type RegularExpressionsClientCapabilities struct { // line 12500 + // The engine's name. + Engine string `json:"engine"` + // The engine's version. + Version string `json:"version,omitempty"` +} + +// A full diagnostic report with a set of related documents. +// +// @since 3.17.0 +type RelatedFullDocumentDiagnosticReport struct { // line 7157 + // Diagnostics of related documents. This information is useful + // in programming languages where code in a file A can generate + // diagnostics in a file B which A depends on. An example of + // such a language is C/C++ where marco definitions in a file + // a.cpp and result in errors in a header file b.hpp. + // + // @since 3.17.0 + RelatedDocuments map[DocumentURI]interface{} `json:"relatedDocuments,omitempty"` + FullDocumentDiagnosticReport +} + +// An unchanged diagnostic report with a set of related documents. +// +// @since 3.17.0 +type RelatedUnchangedDocumentDiagnosticReport struct { // line 7196 + // Diagnostics of related documents. This information is useful + // in programming languages where code in a file A can generate + // diagnostics in a file B which A depends on. An example of + // such a language is C/C++ where marco definitions in a file + // a.cpp and result in errors in a header file b.hpp. + // + // @since 3.17.0 + RelatedDocuments map[DocumentURI]interface{} `json:"relatedDocuments,omitempty"` + UnchangedDocumentDiagnosticReport +} + +// A relative pattern is a helper to construct glob patterns that are matched +// relatively to a base URI. The common value for a `baseUri` is a workspace +// folder root, but it can be another absolute URI as well. +// +// @since 3.17.0 +type RelativePattern struct { // line 10736 + // A workspace folder or a base URI to which this pattern will be matched + // against relatively. + BaseURI Or_RelativePattern_baseUri `json:"baseUri"` + // The actual glob pattern; + Pattern Pattern `json:"pattern"` +} +type RenameClientCapabilities struct { // line 11934 + // Whether rename supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Client supports testing for validity of rename operations + // before execution. + // + // @since 3.12.0 + PrepareSupport bool `json:"prepareSupport,omitempty"` + // Client supports the default behavior result. + // + // The value indicates the default behavior used by the + // client. + // + // @since 3.16.0 + PrepareSupportDefaultBehavior *PrepareSupportDefaultBehavior `json:"prepareSupportDefaultBehavior,omitempty"` + // Whether the client honors the change annotations in + // text edits and resource operations returned via the + // rename request's workspace edit by for example presenting + // the workspace edit in the user interface and asking + // for confirmation. + // + // @since 3.16.0 + HonorsChangeAnnotations bool `json:"honorsChangeAnnotations,omitempty"` +} + +// Rename file operation +type RenameFile struct { // line 6749 + // A rename + Kind string `json:"kind"` + // The old (existing) location. + OldURI DocumentURI `json:"oldUri"` + // The new location. + NewURI DocumentURI `json:"newUri"` + // Rename options. + Options *RenameFileOptions `json:"options,omitempty"` + ResourceOperation +} + +// Rename file options +type RenameFileOptions struct { // line 9441 + // Overwrite target if existing. Overwrite wins over `ignoreIfExists` + Overwrite bool `json:"overwrite,omitempty"` + // Ignores if target exists. + IgnoreIfExists bool `json:"ignoreIfExists,omitempty"` +} + +// The parameters sent in notifications/requests for user-initiated renames of +// files. +// +// @since 3.16.0 +type RenameFilesParams struct { // line 3282 + // An array of all files/folders renamed in this operation. When a folder is renamed, only + // the folder will be included, and not its children. + Files []FileRename `json:"files"` +} + +// Provider options for a {@link RenameRequest}. +type RenameOptions struct { // line 9269 + // Renames should be checked and tested before being executed. + // + // @since version 3.12.0 + PrepareProvider bool `json:"prepareProvider,omitempty"` + WorkDoneProgressOptions +} + +// The parameters of a {@link RenameRequest}. +type RenameParams struct { // line 5874 + // The document to rename. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The position at which this request was sent. + Position Position `json:"position"` + // The new name of the symbol. If the given name is not valid the + // request must return a {@link ResponseError} with an + // appropriate message set. + NewName string `json:"newName"` + WorkDoneProgressParams +} + +// Registration options for a {@link RenameRequest}. +type RenameRegistrationOptions struct { // line 5910 + TextDocumentRegistrationOptions + RenameOptions +} + +// A generic resource operation. +type ResourceOperation struct { // line 9393 + // The resource operation kind. + Kind string `json:"kind"` + // An optional annotation identifier describing the operation. + // + // @since 3.16.0 + AnnotationID *ChangeAnnotationIdentifier `json:"annotationId,omitempty"` +} +type ResourceOperationKind string // line 13669 +// Save options. +type SaveOptions struct { // line 8465 + // The client is supposed to include the content on save. + IncludeText bool `json:"includeText,omitempty"` +} + +// A selection range represents a part of a selection hierarchy. A selection range +// may have a parent selection range that contains it. +type SelectionRange struct { // line 2569 + // The {@link Range range} of this selection range. + Range Range `json:"range"` + // The parent selection range containing this range. Therefore `parent.range` must contain `this.range`. + Parent *SelectionRange `json:"parent,omitempty"` +} +type SelectionRangeClientCapabilities struct { // line 12058 + // Whether implementation supports dynamic registration for selection range providers. If this is set to `true` + // the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server + // capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} +type SelectionRangeOptions struct { // line 6524 + WorkDoneProgressOptions +} + +// A parameter literal used in selection range requests. +type SelectionRangeParams struct { // line 2534 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The positions inside the text document. + Positions []Position `json:"positions"` + WorkDoneProgressParams + PartialResultParams +} +type SelectionRangeRegistrationOptions struct { // line 2592 + SelectionRangeOptions + TextDocumentRegistrationOptions + StaticRegistrationOptions +} + +// A set of predefined token modifiers. This set is not fixed +// an clients can specify additional token types via the +// corresponding client capabilities. +// +// @since 3.16.0 +type SemanticTokenModifiers string // line 12670 +// A set of predefined token types. This set is not fixed +// an clients can specify additional token types via the +// corresponding client capabilities. +// +// @since 3.16.0 +type SemanticTokenTypes string // line 12563 +// @since 3.16.0 +type SemanticTokens struct { // line 2880 + // An optional result id. If provided and clients support delta updating + // the client will include the result id in the next semantic token request. + // A server can then instead of computing all semantic tokens again simply + // send a delta. + ResultID string `json:"resultId,omitempty"` + // The actual tokens. + Data []uint32 `json:"data"` +} + +// @since 3.16.0 +type SemanticTokensClientCapabilities struct { // line 12157 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + // return value for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Which requests the client supports and might send to the server + // depending on the server's capability. Please note that clients might not + // show semantic tokens or degrade some of the user experience if a range + // or full request is advertised by the client but not provided by the + // server. If for example the client capability `requests.full` and + // `request.range` are both set to true but the server only provides a + // range provider the client might not render a minimap correctly or might + // even decide to not show any semantic tokens at all. + Requests PRequestsPSemanticTokens `json:"requests"` + // The token types that the client supports. + TokenTypes []string `json:"tokenTypes"` + // The token modifiers that the client supports. + TokenModifiers []string `json:"tokenModifiers"` + // The token formats the clients supports. + Formats []TokenFormat `json:"formats"` + // Whether the client supports tokens that can overlap each other. + OverlappingTokenSupport bool `json:"overlappingTokenSupport,omitempty"` + // Whether the client supports tokens that can span multiple lines. + MultilineTokenSupport bool `json:"multilineTokenSupport,omitempty"` + // Whether the client allows the server to actively cancel a + // semantic token request, e.g. supports returning + // LSPErrorCodes.ServerCancelled. If a server does the client + // needs to retrigger the request. + // + // @since 3.17.0 + ServerCancelSupport bool `json:"serverCancelSupport,omitempty"` + // Whether the client uses semantic tokens to augment existing + // syntax tokens. If set to `true` client side created syntax + // tokens and semantic tokens are both used for colorization. If + // set to `false` the client only uses the returned semantic tokens + // for colorization. + // + // If the value is `undefined` then the client behavior is not + // specified. + // + // @since 3.17.0 + AugmentsSyntaxTokens bool `json:"augmentsSyntaxTokens,omitempty"` +} + +// @since 3.16.0 +type SemanticTokensDelta struct { // line 2979 + ResultID string `json:"resultId,omitempty"` + // The semantic token edits to transform a previous result into a new result. + Edits []SemanticTokensEdit `json:"edits"` +} + +// @since 3.16.0 +type SemanticTokensDeltaParams struct { // line 2946 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The result id of a previous response. The result Id can either point to a full response + // or a delta response depending on what was received last. + PreviousResultID string `json:"previousResultId"` + WorkDoneProgressParams + PartialResultParams +} + +// @since 3.16.0 +type SemanticTokensDeltaPartialResult struct { // line 3005 + Edits []SemanticTokensEdit `json:"edits"` +} + +// @since 3.16.0 +type SemanticTokensEdit struct { // line 6617 + // The start offset of the edit. + Start uint32 `json:"start"` + // The count of elements to remove. + DeleteCount uint32 `json:"deleteCount"` + // The elements to insert. + Data []uint32 `json:"data,omitempty"` +} + +// @since 3.16.0 +type SemanticTokensLegend struct { // line 9314 + // The token types a server uses. + TokenTypes []string `json:"tokenTypes"` + // The token modifiers a server uses. + TokenModifiers []string `json:"tokenModifiers"` +} + +// @since 3.16.0 +type SemanticTokensOptions struct { // line 6546 + // The legend used by the server + Legend SemanticTokensLegend `json:"legend"` + // Server supports providing semantic tokens for a specific range + // of a document. + Range *Or_SemanticTokensOptions_range `json:"range,omitempty"` + // Server supports providing semantic tokens for a full document. + Full *Or_SemanticTokensOptions_full `json:"full,omitempty"` + WorkDoneProgressOptions +} + +// @since 3.16.0 +type SemanticTokensParams struct { // line 2855 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + WorkDoneProgressParams + PartialResultParams +} + +// @since 3.16.0 +type SemanticTokensPartialResult struct { // line 2907 + Data []uint32 `json:"data"` +} + +// @since 3.16.0 +type SemanticTokensRangeParams struct { // line 3022 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The range the semantic tokens are requested for. + Range Range `json:"range"` + WorkDoneProgressParams + PartialResultParams +} + +// @since 3.16.0 +type SemanticTokensRegistrationOptions struct { // line 2924 + TextDocumentRegistrationOptions + SemanticTokensOptions + StaticRegistrationOptions +} + +// @since 3.16.0 +type SemanticTokensWorkspaceClientCapabilities struct { // line 10977 + // 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 + // semantic tokens 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 `json:"refreshSupport,omitempty"` +} + +// Defines the capabilities provided by a language +// server. +type ServerCapabilities struct { // line 7809 + // The position encoding the server picked from the encodings offered + // by the client via the client capability `general.positionEncodings`. + // + // If the client didn't provide any position encodings the only valid + // value that a server can return is 'utf-16'. + // + // If omitted it defaults to 'utf-16'. + // + // @since 3.17.0 + PositionEncoding *PositionEncodingKind `json:"positionEncoding,omitempty"` + // Defines how text documents are synced. Is either a detailed structure + // defining each notification or for backwards compatibility the + // TextDocumentSyncKind number. + TextDocumentSync interface{} `json:"textDocumentSync,omitempty"` + // Defines how notebook documents are synced. + // + // @since 3.17.0 + NotebookDocumentSync *Or_ServerCapabilities_notebookDocumentSync `json:"notebookDocumentSync,omitempty"` + // The server provides completion support. + CompletionProvider *CompletionOptions `json:"completionProvider,omitempty"` + // The server provides hover support. + HoverProvider *Or_ServerCapabilities_hoverProvider `json:"hoverProvider,omitempty"` + // The server provides signature help support. + SignatureHelpProvider *SignatureHelpOptions `json:"signatureHelpProvider,omitempty"` + // The server provides Goto Declaration support. + DeclarationProvider *Or_ServerCapabilities_declarationProvider `json:"declarationProvider,omitempty"` + // The server provides goto definition support. + DefinitionProvider *Or_ServerCapabilities_definitionProvider `json:"definitionProvider,omitempty"` + // The server provides Goto Type Definition support. + TypeDefinitionProvider *Or_ServerCapabilities_typeDefinitionProvider `json:"typeDefinitionProvider,omitempty"` + // The server provides Goto Implementation support. + ImplementationProvider *Or_ServerCapabilities_implementationProvider `json:"implementationProvider,omitempty"` + // The server provides find references support. + ReferencesProvider *Or_ServerCapabilities_referencesProvider `json:"referencesProvider,omitempty"` + // The server provides document highlight support. + DocumentHighlightProvider *Or_ServerCapabilities_documentHighlightProvider `json:"documentHighlightProvider,omitempty"` + // The server provides document symbol support. + DocumentSymbolProvider *Or_ServerCapabilities_documentSymbolProvider `json:"documentSymbolProvider,omitempty"` + // The server provides code actions. CodeActionOptions may only be + // specified if the client states that it supports + // `codeActionLiteralSupport` in its initial `initialize` request. + CodeActionProvider interface{} `json:"codeActionProvider,omitempty"` + // The server provides code lens. + CodeLensProvider *CodeLensOptions `json:"codeLensProvider,omitempty"` + // The server provides document link support. + DocumentLinkProvider *DocumentLinkOptions `json:"documentLinkProvider,omitempty"` + // The server provides color provider support. + ColorProvider *Or_ServerCapabilities_colorProvider `json:"colorProvider,omitempty"` + // The server provides workspace symbol support. + WorkspaceSymbolProvider *Or_ServerCapabilities_workspaceSymbolProvider `json:"workspaceSymbolProvider,omitempty"` + // The server provides document formatting. + DocumentFormattingProvider *Or_ServerCapabilities_documentFormattingProvider `json:"documentFormattingProvider,omitempty"` + // The server provides document range formatting. + DocumentRangeFormattingProvider *Or_ServerCapabilities_documentRangeFormattingProvider `json:"documentRangeFormattingProvider,omitempty"` + // The server provides document formatting on typing. + DocumentOnTypeFormattingProvider *DocumentOnTypeFormattingOptions `json:"documentOnTypeFormattingProvider,omitempty"` + // The server provides rename support. RenameOptions may only be + // specified if the client states that it supports + // `prepareSupport` in its initial `initialize` request. + RenameProvider interface{} `json:"renameProvider,omitempty"` + // The server provides folding provider support. + FoldingRangeProvider *Or_ServerCapabilities_foldingRangeProvider `json:"foldingRangeProvider,omitempty"` + // The server provides selection range support. + SelectionRangeProvider *Or_ServerCapabilities_selectionRangeProvider `json:"selectionRangeProvider,omitempty"` + // The server provides execute command support. + ExecuteCommandProvider *ExecuteCommandOptions `json:"executeCommandProvider,omitempty"` + // The server provides call hierarchy support. + // + // @since 3.16.0 + CallHierarchyProvider *Or_ServerCapabilities_callHierarchyProvider `json:"callHierarchyProvider,omitempty"` + // The server provides linked editing range support. + // + // @since 3.16.0 + LinkedEditingRangeProvider *Or_ServerCapabilities_linkedEditingRangeProvider `json:"linkedEditingRangeProvider,omitempty"` + // The server provides semantic tokens support. + // + // @since 3.16.0 + SemanticTokensProvider interface{} `json:"semanticTokensProvider,omitempty"` + // The server provides moniker support. + // + // @since 3.16.0 + MonikerProvider *Or_ServerCapabilities_monikerProvider `json:"monikerProvider,omitempty"` + // The server provides type hierarchy support. + // + // @since 3.17.0 + TypeHierarchyProvider *Or_ServerCapabilities_typeHierarchyProvider `json:"typeHierarchyProvider,omitempty"` + // The server provides inline values. + // + // @since 3.17.0 + InlineValueProvider *Or_ServerCapabilities_inlineValueProvider `json:"inlineValueProvider,omitempty"` + // The server provides inlay hints. + // + // @since 3.17.0 + InlayHintProvider interface{} `json:"inlayHintProvider,omitempty"` + // The server has support for pull model diagnostics. + // + // @since 3.17.0 + DiagnosticProvider *Or_ServerCapabilities_diagnosticProvider `json:"diagnosticProvider,omitempty"` + // Workspace specific server capabilities. + Workspace *Workspace6Gn `json:"workspace,omitempty"` + // Experimental server capabilities. + Experimental interface{} `json:"experimental,omitempty"` +} +type SetTraceParams struct { // line 6147 + Value TraceValues `json:"value"` +} + +// Client capabilities for the showDocument request. +// +// @since 3.16.0 +type ShowDocumentClientCapabilities struct { // line 12485 + // The client has support for the showDocument + // request. + Support bool `json:"support"` +} + +// Params to show a document. +// +// @since 3.16.0 +type ShowDocumentParams struct { // line 3055 + // The document uri to show. + URI URI `json:"uri"` + // Indicates to show the resource in an external program. + // To show for example `https://code.visualstudio.com/` + // in the default WEB browser set `external` to `true`. + External bool `json:"external,omitempty"` + // An optional property to indicate whether the editor + // showing the document should take focus or not. + // Clients might ignore this property if an external + // program is started. + TakeFocus bool `json:"takeFocus,omitempty"` + // An optional selection range if the document is a text + // document. Clients might ignore the property if an + // external program is started or the file is not a text + // file. + Selection *Range `json:"selection,omitempty"` +} + +// The result of a showDocument request. +// +// @since 3.16.0 +type ShowDocumentResult struct { // line 3097 + // A boolean indicating if the show was successful. + Success bool `json:"success"` +} + +// The parameters of a notification message. +type ShowMessageParams struct { // line 4183 + // The message type. See {@link MessageType} + Type MessageType `json:"type"` + // The actual message. + Message string `json:"message"` +} + +// Show message request client capabilities +type ShowMessageRequestClientCapabilities struct { // line 12458 + // Capabilities specific to the `MessageActionItem` type. + MessageActionItem *PMessageActionItemPShowMessage `json:"messageActionItem,omitempty"` +} +type ShowMessageRequestParams struct { // line 4205 + // The message type. See {@link MessageType} + Type MessageType `json:"type"` + // The actual message. + Message string `json:"message"` + // The message action items to present. + Actions []MessageActionItem `json:"actions,omitempty"` +} + +// Signature help represents the signature of something +// callable. There can be multiple signature but only one +// active and only one active parameter. +type SignatureHelp struct { // line 4968 + // One or more signatures. + Signatures []SignatureInformation `json:"signatures"` + // The active signature. If omitted or the value lies outside the + // range of `signatures` the value defaults to zero or is ignored if + // the `SignatureHelp` has no signatures. + // + // Whenever possible implementors should make an active decision about + // the active signature and shouldn't rely on a default value. + // + // In future version of the protocol this property might become + // mandatory to better express this. + ActiveSignature uint32 `json:"activeSignature,omitempty"` + // The active parameter of the active signature. If omitted or the value + // lies outside the range of `signatures[activeSignature].parameters` + // defaults to 0 if the active signature has parameters. If + // the active signature has no parameters it is ignored. + // In future version of the protocol this property might become + // mandatory to better express the active parameter if the + // active signature does have any. + ActiveParameter uint32 `json:"activeParameter,omitempty"` +} + +// Client Capabilities for a {@link SignatureHelpRequest}. +type SignatureHelpClientCapabilities struct { // line 11428 + // Whether signature help supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports the following `SignatureInformation` + // specific properties. + SignatureInformation *PSignatureInformationPSignatureHelp `json:"signatureInformation,omitempty"` + // The client supports to send additional context information for a + // `textDocument/signatureHelp` request. A client that opts into + // contextSupport will also support the `retriggerCharacters` on + // `SignatureHelpOptions`. + // + // @since 3.15.0 + ContextSupport bool `json:"contextSupport,omitempty"` +} + +// Additional information about the context in which a signature help request was triggered. +// +// @since 3.15.0 +type SignatureHelpContext struct { // line 8787 + // Action that caused signature help to be triggered. + TriggerKind SignatureHelpTriggerKind `json:"triggerKind"` + // Character that caused signature help to be triggered. + // + // This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter` + TriggerCharacter string `json:"triggerCharacter,omitempty"` + // `true` if signature help was already showing when it was triggered. + // + // Retriggers occurs when the signature help is already active and can be caused by actions such as + // typing a trigger character, a cursor move, or document content changes. + IsRetrigger bool `json:"isRetrigger"` + // The currently active `SignatureHelp`. + // + // The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on + // the user navigating through available signatures. + ActiveSignatureHelp *SignatureHelp `json:"activeSignatureHelp,omitempty"` +} + +// Server Capabilities for a {@link SignatureHelpRequest}. +type SignatureHelpOptions struct { // line 8882 + // List of characters that trigger signature help automatically. + TriggerCharacters []string `json:"triggerCharacters,omitempty"` + // List of characters that re-trigger signature help. + // + // These trigger characters are only active when signature help is already showing. All trigger characters + // are also counted as re-trigger characters. + // + // @since 3.15.0 + RetriggerCharacters []string `json:"retriggerCharacters,omitempty"` + WorkDoneProgressOptions +} + +// Parameters for a {@link SignatureHelpRequest}. +type SignatureHelpParams struct { // line 4940 + // The signature help context. This is only available if the client specifies + // to send this using the client capability `textDocument.signatureHelp.contextSupport === true` + // + // @since 3.15.0 + Context *SignatureHelpContext `json:"context,omitempty"` + TextDocumentPositionParams + WorkDoneProgressParams +} + +// Registration options for a {@link SignatureHelpRequest}. +type SignatureHelpRegistrationOptions struct { // line 5003 + TextDocumentRegistrationOptions + SignatureHelpOptions +} + +// How a signature help was triggered. +// +// @since 3.15.0 +type SignatureHelpTriggerKind uint32 // line 13580 +// Represents the signature of something callable. A signature +// can have a label, like a function-name, a doc-comment, and +// a set of parameters. +type SignatureInformation struct { // line 8828 + // The label of this signature. Will be shown in + // the UI. + Label string `json:"label"` + // The human-readable doc-comment of this signature. Will be shown + // in the UI but can be omitted. + Documentation *Or_SignatureInformation_documentation `json:"documentation,omitempty"` + // The parameters of this signature. + Parameters []ParameterInformation `json:"parameters,omitempty"` + // The index of the active parameter. + // + // If provided, this is used in place of `SignatureHelp.activeParameter`. + // + // @since 3.16.0 + ActiveParameter uint32 `json:"activeParameter,omitempty"` +} + +// Static registration options to be returned in the initialize +// request. +type StaticRegistrationOptions struct { // line 6343 + // The id used to register the request. The id can be used to deregister + // the request again. See also Registration#id. + ID string `json:"id,omitempty"` +} + +// Represents information about programming constructs like variables, classes, +// interfaces etc. +type SymbolInformation struct { // line 5181 + // extends BaseSymbolInformation + // Indicates if this symbol is deprecated. + // + // @deprecated Use tags instead + Deprecated bool `json:"deprecated,omitempty"` + // The location of this symbol. The location's range is used by a tool + // to reveal the location in the editor. If the symbol is selected in the + // tool the range's start information is used to position the cursor. So + // the range usually spans more than the actual symbol's name and does + // normally include things like visibility modifiers. + // + // The range doesn't have to denote a node range in the sense of an abstract + // syntax tree. It can therefore not be used to re-construct a hierarchy of + // the symbols. + Location Location `json:"location"` + // The name of this symbol. + Name string `json:"name"` + // The kind of this symbol. + Kind SymbolKind `json:"kind"` + // Tags for this symbol. + // + // @since 3.16.0 + Tags []SymbolTag `json:"tags,omitempty"` + // The name of the symbol containing this symbol. This information is for + // user interface purposes (e.g. to render a qualifier in the user interface + // if necessary). It can't be used to re-infer a hierarchy for the document + // symbols. + ContainerName string `json:"containerName,omitempty"` +} + +// A symbol kind. +type SymbolKind uint32 // line 12841 +// Symbol tags are extra annotations that tweak the rendering of a symbol. +// +// @since 3.16 +type SymbolTag uint32 // line 12955 +// Describe options to be used when registered for text document change events. +type TextDocumentChangeRegistrationOptions struct { // line 4312 + // How documents are synced to the server. + SyncKind TextDocumentSyncKind `json:"syncKind"` + TextDocumentRegistrationOptions +} + +// Text document specific client capabilities. +type TextDocumentClientCapabilities struct { // line 10323 + // Defines which synchronization capabilities the client supports. + Synchronization *TextDocumentSyncClientCapabilities `json:"synchronization,omitempty"` + // Capabilities specific to the `textDocument/completion` request. + Completion CompletionClientCapabilities `json:"completion,omitempty"` + // Capabilities specific to the `textDocument/hover` request. + Hover *HoverClientCapabilities `json:"hover,omitempty"` + // Capabilities specific to the `textDocument/signatureHelp` request. + SignatureHelp *SignatureHelpClientCapabilities `json:"signatureHelp,omitempty"` + // Capabilities specific to the `textDocument/declaration` request. + // + // @since 3.14.0 + Declaration *DeclarationClientCapabilities `json:"declaration,omitempty"` + // Capabilities specific to the `textDocument/definition` request. + Definition *DefinitionClientCapabilities `json:"definition,omitempty"` + // Capabilities specific to the `textDocument/typeDefinition` request. + // + // @since 3.6.0 + TypeDefinition *TypeDefinitionClientCapabilities `json:"typeDefinition,omitempty"` + // Capabilities specific to the `textDocument/implementation` request. + // + // @since 3.6.0 + Implementation *ImplementationClientCapabilities `json:"implementation,omitempty"` + // Capabilities specific to the `textDocument/references` request. + References *ReferenceClientCapabilities `json:"references,omitempty"` + // Capabilities specific to the `textDocument/documentHighlight` request. + DocumentHighlight *DocumentHighlightClientCapabilities `json:"documentHighlight,omitempty"` + // Capabilities specific to the `textDocument/documentSymbol` request. + DocumentSymbol DocumentSymbolClientCapabilities `json:"documentSymbol,omitempty"` + // Capabilities specific to the `textDocument/codeAction` request. + CodeAction CodeActionClientCapabilities `json:"codeAction,omitempty"` + // Capabilities specific to the `textDocument/codeLens` request. + CodeLens *CodeLensClientCapabilities `json:"codeLens,omitempty"` + // Capabilities specific to the `textDocument/documentLink` request. + DocumentLink *DocumentLinkClientCapabilities `json:"documentLink,omitempty"` + // Capabilities specific to the `textDocument/documentColor` and the + // `textDocument/colorPresentation` request. + // + // @since 3.6.0 + ColorProvider *DocumentColorClientCapabilities `json:"colorProvider,omitempty"` + // Capabilities specific to the `textDocument/formatting` request. + Formatting *DocumentFormattingClientCapabilities `json:"formatting,omitempty"` + // Capabilities specific to the `textDocument/rangeFormatting` request. + RangeFormatting *DocumentRangeFormattingClientCapabilities `json:"rangeFormatting,omitempty"` + // Capabilities specific to the `textDocument/onTypeFormatting` request. + OnTypeFormatting *DocumentOnTypeFormattingClientCapabilities `json:"onTypeFormatting,omitempty"` + // Capabilities specific to the `textDocument/rename` request. + Rename *RenameClientCapabilities `json:"rename,omitempty"` + // Capabilities specific to the `textDocument/foldingRange` request. + // + // @since 3.10.0 + FoldingRange *FoldingRangeClientCapabilities `json:"foldingRange,omitempty"` + // Capabilities specific to the `textDocument/selectionRange` request. + // + // @since 3.15.0 + SelectionRange *SelectionRangeClientCapabilities `json:"selectionRange,omitempty"` + // Capabilities specific to the `textDocument/publishDiagnostics` notification. + PublishDiagnostics PublishDiagnosticsClientCapabilities `json:"publishDiagnostics,omitempty"` + // Capabilities specific to the various call hierarchy requests. + // + // @since 3.16.0 + CallHierarchy *CallHierarchyClientCapabilities `json:"callHierarchy,omitempty"` + // Capabilities specific to the various semantic token request. + // + // @since 3.16.0 + SemanticTokens SemanticTokensClientCapabilities `json:"semanticTokens,omitempty"` + // Capabilities specific to the `textDocument/linkedEditingRange` request. + // + // @since 3.16.0 + LinkedEditingRange *LinkedEditingRangeClientCapabilities `json:"linkedEditingRange,omitempty"` + // Client capabilities specific to the `textDocument/moniker` request. + // + // @since 3.16.0 + Moniker *MonikerClientCapabilities `json:"moniker,omitempty"` + // Capabilities specific to the various type hierarchy requests. + // + // @since 3.17.0 + TypeHierarchy *TypeHierarchyClientCapabilities `json:"typeHierarchy,omitempty"` + // Capabilities specific to the `textDocument/inlineValue` request. + // + // @since 3.17.0 + InlineValue *InlineValueClientCapabilities `json:"inlineValue,omitempty"` + // Capabilities specific to the `textDocument/inlayHint` request. + // + // @since 3.17.0 + InlayHint *InlayHintClientCapabilities `json:"inlayHint,omitempty"` + // Capabilities specific to the diagnostic pull model. + // + // @since 3.17.0 + Diagnostic *DiagnosticClientCapabilities `json:"diagnostic,omitempty"` +} + +// An event describing a change to a text document. If only a text is provided +// it is considered to be the full content of the document. +type TextDocumentContentChangeEvent = Msg_TextDocumentContentChangeEvent // (alias) line 14002 +// Describes textual changes on a text document. A TextDocumentEdit describes all changes +// on a document version Si and after they are applied move the document to version Si+1. +// So the creator of a TextDocumentEdit doesn't need to sort the array of edits or do any +// kind of ordering. However the edits must be non overlapping. +type TextDocumentEdit struct { // line 6677 + // The text document to change. + TextDocument OptionalVersionedTextDocumentIdentifier `json:"textDocument"` + // The edits to be applied. + // + // @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a + // client capability. + Edits []TextEdit `json:"edits"` +} + +// A document filter denotes a document by different properties like +// the {@link TextDocument.languageId language}, the {@link Uri.scheme scheme} of +// its resource, or a glob-pattern that is applied to the {@link TextDocument.fileName path}. +// +// Glob patterns can have the following syntax: +// +// - `*` to match one or more characters in a path segment +// - `?` to match on one character in a path segment +// - `**` to match any number of path segments, including none +// - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files) +// - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) +// - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) +// +// @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }` +// @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }` +// +// @since 3.17.0 +type TextDocumentFilter = Msg_TextDocumentFilter // (alias) line 14145 +// A literal to identify a text document in the client. +type TextDocumentIdentifier struct { // line 6419 + // The text document's uri. + URI DocumentURI `json:"uri"` +} + +// An item to transfer a text document from the client to the +// server. +type TextDocumentItem struct { // line 7405 + // The text document's uri. + URI DocumentURI `json:"uri"` + // The text document's language identifier. + LanguageID string `json:"languageId"` + // The version number of this document (it will increase after each + // change, including undo/redo). + Version int32 `json:"version"` + // The content of the opened text document. + Text string `json:"text"` +} + +// A parameter literal used in requests to pass a text document and a position inside that +// document. +type TextDocumentPositionParams struct { // line 6222 + // The text document. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The position inside the text document. + Position Position `json:"position"` +} + +// General text document registration options. +type TextDocumentRegistrationOptions struct { // line 2368 + // A document selector to identify the scope of the registration. If set to null + // the document selector provided on the client side will be used. + DocumentSelector DocumentSelector `json:"documentSelector"` +} + +// Represents reasons why a text document is saved. +type TextDocumentSaveReason uint32 // line 13109 +// Save registration options. +type TextDocumentSaveRegistrationOptions struct { // line 4369 + TextDocumentRegistrationOptions + SaveOptions +} +type TextDocumentSyncClientCapabilities struct { // line 11127 + // Whether text document synchronization supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports sending will save notifications. + WillSave bool `json:"willSave,omitempty"` + // The client supports sending a will save request and + // waits for a response providing text edits which will + // be applied to the document before it is saved. + WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitempty"` + // The client supports did save notifications. + DidSave bool `json:"didSave,omitempty"` +} + +// Defines how the host (editor) should sync +// document changes to the language server. +type TextDocumentSyncKind uint32 // line 13084 +type TextDocumentSyncOptions struct { // line 9736 + // Open and close notifications are sent to the server. If omitted open close notification should not + // be sent. + OpenClose bool `json:"openClose,omitempty"` + // Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full + // and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None. + Change TextDocumentSyncKind `json:"change,omitempty"` + // If present will save notifications are sent to the server. If omitted the notification should not be + // sent. + WillSave bool `json:"willSave,omitempty"` + // If present will save wait until requests are sent to the server. If omitted the request should not be + // sent. + WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitempty"` + // If present save notifications are sent to the server. If omitted the notification should not be + // sent. + Save *SaveOptions `json:"save,omitempty"` +} + +// A text edit applicable to a text document. +type TextEdit struct { // line 4406 + // The range of the text document to be manipulated. To insert + // text into a document create a range where start === end. + Range Range `json:"range"` + // The string to be inserted. For delete operations use an + // empty string. + NewText string `json:"newText"` +} +type TokenFormat string // line 13736 +type TraceValues string // line 13383 +// Since 3.6.0 +type TypeDefinitionClientCapabilities struct { // line 11559 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `TypeDefinitionRegistrationOptions` return value + // for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // The client supports additional metadata in the form of definition links. + // + // Since 3.14.0 + LinkSupport bool `json:"linkSupport,omitempty"` +} +type TypeDefinitionOptions struct { // line 6358 + WorkDoneProgressOptions +} +type TypeDefinitionParams struct { // line 2123 + TextDocumentPositionParams + WorkDoneProgressParams + PartialResultParams +} +type TypeDefinitionRegistrationOptions struct { // line 2143 + TextDocumentRegistrationOptions + TypeDefinitionOptions + StaticRegistrationOptions +} + +// @since 3.17.0 +type TypeHierarchyClientCapabilities struct { // line 12337 + // Whether implementation supports dynamic registration. If this is set to `true` + // the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + // return value for the corresponding server capability as well. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` +} + +// @since 3.17.0 +type TypeHierarchyItem struct { // line 3410 + // The name of this item. + Name string `json:"name"` + // The kind of this item. + Kind SymbolKind `json:"kind"` + // Tags for this item. + Tags []SymbolTag `json:"tags,omitempty"` + // More detail for this item, e.g. the signature of a function. + Detail string `json:"detail,omitempty"` + // The resource identifier of this item. + URI DocumentURI `json:"uri"` + // The range enclosing this symbol not including leading/trailing whitespace + // but everything else, e.g. comments and code. + Range Range `json:"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 + // {@link TypeHierarchyItem.range `range`}. + SelectionRange Range `json:"selectionRange"` + // A data entry field that is preserved between a type hierarchy prepare and + // supertypes or subtypes requests. It could also be used to identify the + // type hierarchy in the server, helping improve the performance on + // resolving supertypes and subtypes. + Data interface{} `json:"data,omitempty"` +} + +// Type hierarchy options used during static registration. +// +// @since 3.17.0 +type TypeHierarchyOptions struct { // line 6936 + WorkDoneProgressOptions +} + +// The parameter of a `textDocument/prepareTypeHierarchy` request. +// +// @since 3.17.0 +type TypeHierarchyPrepareParams struct { // line 3392 + TextDocumentPositionParams + WorkDoneProgressParams +} + +// Type hierarchy options used during static or dynamic registration. +// +// @since 3.17.0 +type TypeHierarchyRegistrationOptions struct { // line 3487 + TextDocumentRegistrationOptions + TypeHierarchyOptions + StaticRegistrationOptions +} + +// The parameter of a `typeHierarchy/subtypes` request. +// +// @since 3.17.0 +type TypeHierarchySubtypesParams struct { // line 3533 + Item TypeHierarchyItem `json:"item"` + WorkDoneProgressParams + PartialResultParams +} + +// The parameter of a `typeHierarchy/supertypes` request. +// +// @since 3.17.0 +type TypeHierarchySupertypesParams struct { // line 3509 + Item TypeHierarchyItem `json:"item"` + WorkDoneProgressParams + PartialResultParams +} + +// created for Tuple +type UIntCommaUInt struct { // line 10076 + Fld0 uint32 `json:"fld0"` + Fld1 uint32 `json:"fld1"` +} +type URI = string + +// A diagnostic report indicating that the last returned +// report is still accurate. +// +// @since 3.17.0 +type UnchangedDocumentDiagnosticReport struct { // line 7270 + // A document diagnostic report indicating + // no changes to the last result. A server can + // only return `unchanged` if result ids are + // provided. + Kind string `json:"kind"` + // A result id which will be sent on the next + // diagnostic request for the same document. + ResultID string `json:"resultId"` +} + +// Moniker uniqueness level to define scope of the moniker. +// +// @since 3.16.0 +type UniquenessLevel string // line 12971 +// General parameters to unregister a request or notification. +type Unregistration struct { // line 7628 + // The id used to unregister the request or notification. Usually an id + // provided during the register request. + ID string `json:"id"` + // The method to unregister for. + Method string `json:"method"` +} +type UnregistrationParams struct { // line 4053 + Unregisterations []Unregistration `json:"unregisterations"` +} + +// A versioned notebook document identifier. +// +// @since 3.17.0 +type VersionedNotebookDocumentIdentifier struct { // line 7443 + // The version number of this notebook document. + Version int32 `json:"version"` + // The notebook document's uri. + URI URI `json:"uri"` +} + +// A text document identifier to denote a specific version of a text document. +type VersionedTextDocumentIdentifier struct { // line 8445 + // The version number of this document. + Version int32 `json:"version"` + TextDocumentIdentifier +} +type WatchKind = uint32 // line 13505// The parameters sent in a will save text document notification. +type WillSaveTextDocumentParams struct { // line 4384 + // The document that will be saved. + TextDocument TextDocumentIdentifier `json:"textDocument"` + // The 'TextDocumentSaveReason'. + Reason TextDocumentSaveReason `json:"reason"` +} +type WindowClientCapabilities struct { // line 10629 + // It indicates whether the client supports server initiated + // progress using the `window/workDoneProgress/create` request. + // + // The capability also controls Whether client supports handling + // of progress notifications. If set servers are allowed to report a + // `workDoneProgress` property in the request specific server + // capabilities. + // + // @since 3.15.0 + WorkDoneProgress bool `json:"workDoneProgress,omitempty"` + // Capabilities specific to the showMessage request. + // + // @since 3.16.0 + ShowMessage *ShowMessageRequestClientCapabilities `json:"showMessage,omitempty"` + // Capabilities specific to the showDocument request. + // + // @since 3.16.0 + ShowDocument *ShowDocumentClientCapabilities `json:"showDocument,omitempty"` +} +type WorkDoneProgressBegin struct { // line 6040 + Kind string `json:"kind"` + // Mandatory title of the progress operation. Used to briefly inform about + // the kind of operation being performed. + // + // Examples: "Indexing" or "Linking dependencies". + Title string `json:"title"` + // Controls if a cancel button should show to allow the user to cancel the + // long running operation. Clients that don't support cancellation are allowed + // to ignore the setting. + Cancellable bool `json:"cancellable,omitempty"` + // Optional, more detailed associated progress message. Contains + // complementary information to the `title`. + // + // Examples: "3/25 files", "project/src/module2", "node_modules/some_dep". + // If unset, the previous progress message (if any) is still valid. + Message string `json:"message,omitempty"` + // Optional progress percentage to display (value 100 is considered 100%). + // If not provided infinite progress is assumed and clients are allowed + // to ignore the `percentage` value in subsequent in report notifications. + // + // The value should be steadily rising. Clients are free to ignore values + // that are not following this rule. The value range is [0, 100]. + Percentage uint32 `json:"percentage,omitempty"` +} +type WorkDoneProgressCancelParams struct { // line 2625 + // The token to be used to report progress. + Token ProgressToken `json:"token"` +} +type WorkDoneProgressCreateParams struct { // line 2612 + // The token to be used to report progress. + Token ProgressToken `json:"token"` +} +type WorkDoneProgressEnd struct { // line 6126 + Kind string `json:"kind"` + // Optional, a final message indicating to for example indicate the outcome + // of the operation. + Message string `json:"message,omitempty"` +} +type WorkDoneProgressOptions struct { // line 2355 + WorkDoneProgress bool `json:"workDoneProgress,omitempty"` +} + +// created for And +type WorkDoneProgressOptionsAndTextDocumentRegistrationOptions struct { // line 196 + WorkDoneProgressOptions + TextDocumentRegistrationOptions +} +type WorkDoneProgressParams struct { // line 6244 + // An optional token that a server can use to report work done progress. + WorkDoneToken ProgressToken `json:"workDoneToken,omitempty"` +} +type WorkDoneProgressReport struct { // line 6087 + Kind string `json:"kind"` + // Controls enablement state of a cancel button. + // + // Clients that don't support cancellation or don't support controlling the button's + // enablement state are allowed to ignore the property. + Cancellable bool `json:"cancellable,omitempty"` + // Optional, more detailed associated progress message. Contains + // complementary information to the `title`. + // + // Examples: "3/25 files", "project/src/module2", "node_modules/some_dep". + // If unset, the previous progress message (if any) is still valid. + Message string `json:"message,omitempty"` + // Optional progress percentage to display (value 100 is considered 100%). + // If not provided infinite progress is assumed and clients are allowed + // to ignore the `percentage` value in subsequent in report notifications. + // + // The value should be steadily rising. Clients are free to ignore values + // that are not following this rule. The value range is [0, 100] + Percentage uint32 `json:"percentage,omitempty"` +} + +// created for Literal (Lit_ServerCapabilities_workspace) +type Workspace6Gn struct { // line 8404 + // The server supports workspace folder. + // + // @since 3.6.0 + WorkspaceFolders *WorkspaceFolders5Gn `json:"workspaceFolders,omitempty"` + // The server is interested in notifications/requests for operations on files. + // + // @since 3.16.0 + FileOperations *FileOperationOptions `json:"fileOperations,omitempty"` +} + +// Workspace specific client capabilities. +type WorkspaceClientCapabilities struct { // line 10184 + // The client supports applying batch edits + // to the workspace by supporting the request + // 'workspace/applyEdit' + ApplyEdit bool `json:"applyEdit,omitempty"` + // Capabilities specific to `WorkspaceEdit`s. + WorkspaceEdit *WorkspaceEditClientCapabilities `json:"workspaceEdit,omitempty"` + // Capabilities specific to the `workspace/didChangeConfiguration` notification. + DidChangeConfiguration DidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitempty"` + // Capabilities specific to the `workspace/didChangeWatchedFiles` notification. + DidChangeWatchedFiles DidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitempty"` + // Capabilities specific to the `workspace/symbol` request. + Symbol *WorkspaceSymbolClientCapabilities `json:"symbol,omitempty"` + // Capabilities specific to the `workspace/executeCommand` request. + ExecuteCommand *ExecuteCommandClientCapabilities `json:"executeCommand,omitempty"` + // The client has support for workspace folders. + // + // @since 3.6.0 + WorkspaceFolders bool `json:"workspaceFolders,omitempty"` + // The client supports `workspace/configuration` requests. + // + // @since 3.6.0 + Configuration bool `json:"configuration,omitempty"` + // Capabilities specific to the semantic token requests scoped to the + // workspace. + // + // @since 3.16.0. + SemanticTokens *SemanticTokensWorkspaceClientCapabilities `json:"semanticTokens,omitempty"` + // Capabilities specific to the code lens requests scoped to the + // workspace. + // + // @since 3.16.0. + CodeLens *CodeLensWorkspaceClientCapabilities `json:"codeLens,omitempty"` + // The client has support for file notifications/requests for user operations on files. + // + // Since 3.16.0 + FileOperations *FileOperationClientCapabilities `json:"fileOperations,omitempty"` + // Capabilities specific to the inline values requests scoped to the + // workspace. + // + // @since 3.17.0. + InlineValue *InlineValueWorkspaceClientCapabilities `json:"inlineValue,omitempty"` + // Capabilities specific to the inlay hint requests scoped to the + // workspace. + // + // @since 3.17.0. + InlayHint *InlayHintWorkspaceClientCapabilities `json:"inlayHint,omitempty"` + // Capabilities specific to the diagnostic requests scoped to the + // workspace. + // + // @since 3.17.0. + Diagnostics *DiagnosticWorkspaceClientCapabilities `json:"diagnostics,omitempty"` +} + +// Parameters of the workspace diagnostic request. +// +// @since 3.17.0 +type WorkspaceDiagnosticParams struct { // line 3877 + // The additional identifier provided during registration. + Identifier string `json:"identifier,omitempty"` + // The currently known diagnostic reports with their + // previous result ids. + PreviousResultIds []PreviousResultID `json:"previousResultIds"` + WorkDoneProgressParams + PartialResultParams +} + +// A workspace diagnostic report. +// +// @since 3.17.0 +type WorkspaceDiagnosticReport struct { // line 3914 + Items []WorkspaceDocumentDiagnosticReport `json:"items"` +} + +// A partial result for a workspace diagnostic report. +// +// @since 3.17.0 +type WorkspaceDiagnosticReportPartialResult struct { // line 3931 + Items []WorkspaceDocumentDiagnosticReport `json:"items"` +} + +// A workspace diagnostic document report. +// +// @since 3.17.0 +type WorkspaceDocumentDiagnosticReport = Or_WorkspaceDocumentDiagnosticReport // (alias) line 13984 +// A workspace edit represents changes to many resources managed in the workspace. The edit +// should either provide `changes` or `documentChanges`. If documentChanges are present +// they are preferred over `changes` if the client can handle versioned document edits. +// +// Since version 3.13.0 a workspace edit can contain resource operations as well. If resource +// operations are present clients need to execute the operations in the order in which they +// are provided. So a workspace edit for example can consist of the following two changes: +// (1) a create file a.txt and (2) a text document edit which insert text into file a.txt. +// +// An invalid sequence (e.g. (1) delete file a.txt and (2) insert text into file a.txt) will +// cause failure of the operation. How the client recovers from the failure is described by +// the client capability: `workspace.workspaceEdit.failureHandling` +type WorkspaceEdit struct { // line 3193 + // Holds changes to existing resources. + Changes map[DocumentURI][]TextEdit `json:"changes,omitempty"` + // Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes + // are either an array of `TextDocumentEdit`s to express changes to n different text documents + // where each text document edit addresses a specific version of a text document. Or it can contain + // above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations. + // + // Whether a client supports versioned document edits is expressed via + // `workspace.workspaceEdit.documentChanges` client capability. + // + // If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then + // only plain `TextEdit`s using the `changes` property are supported. + DocumentChanges []DocumentChanges `json:"documentChanges,omitempty"` + // A map of change annotations that can be referenced in `AnnotatedTextEdit`s or create, rename and + // delete file / folder operations. + // + // Whether clients honor this property depends on the client capability `workspace.changeAnnotationSupport`. + // + // @since 3.16.0 + ChangeAnnotations map[ChangeAnnotationIdentifier]ChangeAnnotation `json:"changeAnnotations,omitempty"` +} +type WorkspaceEditClientCapabilities struct { // line 10768 + // The client supports versioned document changes in `WorkspaceEdit`s + DocumentChanges bool `json:"documentChanges,omitempty"` + // The resource operations the client supports. Clients should at least + // support 'create', 'rename' and 'delete' files and folders. + // + // @since 3.13.0 + ResourceOperations []ResourceOperationKind `json:"resourceOperations,omitempty"` + // The failure handling strategy of a client if applying the workspace edit + // fails. + // + // @since 3.13.0 + FailureHandling *FailureHandlingKind `json:"failureHandling,omitempty"` + // Whether the client normalizes line endings to the client specific + // setting. + // If set to `true` the client will normalize line ending characters + // in a workspace edit to the client-specified new line + // character. + // + // @since 3.16.0 + NormalizesLineEndings bool `json:"normalizesLineEndings,omitempty"` + // Whether the client in general supports change annotations on text edits, + // create file, rename file and delete file changes. + // + // @since 3.16.0 + ChangeAnnotationSupport *PChangeAnnotationSupportPWorkspaceEdit `json:"changeAnnotationSupport,omitempty"` +} + +// A workspace folder inside a client. +type WorkspaceFolder struct { // line 2163 + // The associated URI for this workspace folder. + URI URI `json:"uri"` + // The name of the workspace folder. Used to refer to this + // workspace folder in the user interface. + Name string `json:"name"` +} +type WorkspaceFolders5Gn struct { // line 9933 + // The server has support for workspace folders + Supported bool `json:"supported,omitempty"` + // Whether the server wants to receive workspace folder + // change notifications. + // + // If a string is provided the string is treated as an ID + // under which the notification is registered on the client + // side. The ID can be used to unregister for these events + // using the `client/unregisterCapability` request. + ChangeNotifications string `json:"changeNotifications,omitempty"` +} + +// The workspace folder change event. +type WorkspaceFoldersChangeEvent struct { // line 6368 + // The array of added workspace folders + Added []WorkspaceFolder `json:"added"` + // The array of the removed workspace folders + Removed []WorkspaceFolder `json:"removed"` +} +type WorkspaceFoldersInitializeParams struct { // line 7782 + // The workspace folders configured in the client when the server starts. + // + // This property is only available if the client supports workspace folders. + // It can be `null` if the client supports workspace folders but none are + // configured. + // + // @since 3.6.0 + WorkspaceFolders []WorkspaceFolder `json:"workspaceFolders,omitempty"` +} +type WorkspaceFoldersServerCapabilities struct { // line 9933 + // The server has support for workspace folders + Supported bool `json:"supported,omitempty"` + // Whether the server wants to receive workspace folder + // change notifications. + // + // If a string is provided the string is treated as an ID + // under which the notification is registered on the client + // side. The ID can be used to unregister for these events + // using the `client/unregisterCapability` request. + ChangeNotifications string `json:"changeNotifications,omitempty"` +} + +// A full document diagnostic report for a workspace diagnostic result. +// +// @since 3.17.0 +type WorkspaceFullDocumentDiagnosticReport struct { // line 9522 + // The URI for which diagnostic information is reported. + URI DocumentURI `json:"uri"` + // The version number for which the diagnostics are reported. + // If the document is not marked as open `null` can be provided. + Version int32 `json:"version"` + FullDocumentDiagnosticReport +} + +// A special workspace symbol that supports locations without a range. +// +// See also SymbolInformation. +// +// @since 3.17.0 +type WorkspaceSymbol struct { // line 5515 + // The location of the symbol. Whether a server is allowed to + // return a location without a range depends on the client + // capability `workspace.symbol.resolveSupport`. + // + // See SymbolInformation#location for more details. + Location OrPLocation_workspace_symbol `json:"location"` + // A data entry field that is preserved on a workspace symbol between a + // workspace symbol request and a workspace symbol resolve request. + Data interface{} `json:"data,omitempty"` + BaseSymbolInformation +} + +// Client capabilities for a {@link WorkspaceSymbolRequest}. +type WorkspaceSymbolClientCapabilities struct { // line 10875 + // Symbol request supports dynamic registration. + DynamicRegistration bool `json:"dynamicRegistration,omitempty"` + // Specific capabilities for the `SymbolKind` in the `workspace/symbol` request. + SymbolKind *PSymbolKindPSymbol `json:"symbolKind,omitempty"` + // The client supports tags on `SymbolInformation`. + // Clients supporting tags have to handle unknown tags gracefully. + // + // @since 3.16.0 + TagSupport *PTagSupportPSymbol `json:"tagSupport,omitempty"` + // The client support partial workspace symbols. The client will send the + // request `workspaceSymbol/resolve` to the server to resolve additional + // properties. + // + // @since 3.17.0 + ResolveSupport *PResolveSupportPSymbol `json:"resolveSupport,omitempty"` +} + +// Server capabilities for a {@link WorkspaceSymbolRequest}. +type WorkspaceSymbolOptions struct { // line 9105 + // The server provides support to resolve additional + // information for a workspace symbol. + // + // @since 3.17.0 + ResolveProvider bool `json:"resolveProvider,omitempty"` + WorkDoneProgressOptions +} + +// The parameters of a {@link WorkspaceSymbolRequest}. +type WorkspaceSymbolParams struct { // line 5491 + // A query string to filter symbols by. Clients may send an empty + // string here to request all symbols. + Query string `json:"query"` + WorkDoneProgressParams + PartialResultParams +} + +// Registration options for a {@link WorkspaceSymbolRequest}. +type WorkspaceSymbolRegistrationOptions struct { // line 5564 + WorkspaceSymbolOptions +} + +// An unchanged document diagnostic report for a workspace diagnostic result. +// +// @since 3.17.0 +type WorkspaceUnchangedDocumentDiagnosticReport struct { // line 9560 + // The URI for which diagnostic information is reported. + URI DocumentURI `json:"uri"` + // The version number for which the diagnostics are reported. + // If the document is not marked as open `null` can be provided. + Version int32 `json:"version"` + UnchangedDocumentDiagnosticReport +} + +// The initialize parameters +type XInitializeParams struct { // line 7650 + // The process Id of the parent process that started + // the server. + // + // Is `null` if the process has not been started by another process. + // If the parent process is not alive then the server should exit. + ProcessID int32 `json:"processId"` + // Information about the client + // + // @since 3.15.0 + ClientInfo *Msg_XInitializeParams_clientInfo `json:"clientInfo,omitempty"` + // The locale the client is currently showing the user interface + // in. This must not necessarily be the locale of the operating + // system. + // + // Uses IETF language tags as the value's syntax + // (See https://en.wikipedia.org/wiki/IETF_language_tag) + // + // @since 3.16.0 + Locale string `json:"locale,omitempty"` + // The rootPath of the workspace. Is null + // if no folder is open. + // + // @deprecated in favour of rootUri. + RootPath string `json:"rootPath,omitempty"` + // The rootUri of the workspace. Is null if no + // folder is open. If both `rootPath` and `rootUri` are set + // `rootUri` wins. + // + // @deprecated in favour of workspaceFolders. + RootURI DocumentURI `json:"rootUri"` + // The capabilities provided by the client (editor or tool) + Capabilities ClientCapabilities `json:"capabilities"` + // User provided initialization options. + InitializationOptions interface{} `json:"initializationOptions,omitempty"` + // The initial trace setting. If omitted trace is disabled ('off'). + Trace *TraceValues `json:"trace,omitempty"` + WorkDoneProgressParams +} + +// The initialize parameters +type _InitializeParams struct { // line 7650 + // The process Id of the parent process that started + // the server. + // + // Is `null` if the process has not been started by another process. + // If the parent process is not alive then the server should exit. + ProcessID int32 `json:"processId"` + // Information about the client + // + // @since 3.15.0 + ClientInfo *Msg_XInitializeParams_clientInfo `json:"clientInfo,omitempty"` + // The locale the client is currently showing the user interface + // in. This must not necessarily be the locale of the operating + // system. + // + // Uses IETF language tags as the value's syntax + // (See https://en.wikipedia.org/wiki/IETF_language_tag) + // + // @since 3.16.0 + Locale string `json:"locale,omitempty"` + // The rootPath of the workspace. Is null + // if no folder is open. + // + // @deprecated in favour of rootUri. + RootPath string `json:"rootPath,omitempty"` + // The rootUri of the workspace. Is null if no + // folder is open. If both `rootPath` and `rootUri` are set + // `rootUri` wins. + // + // @deprecated in favour of workspaceFolders. + RootURI DocumentURI `json:"rootUri"` + // The capabilities provided by the client (editor or tool) + Capabilities ClientCapabilities `json:"capabilities"` + // User provided initialization options. + InitializationOptions interface{} `json:"initializationOptions,omitempty"` + // The initial trace setting. If omitted trace is disabled ('off'). + Trace *TraceValues `json:"trace,omitempty"` + WorkDoneProgressParams +} + +const ( + // A set of predefined code action kinds + // Empty kind. + Empty CodeActionKind = "" // line 13333 + // Base kind for quickfix actions: 'quickfix' + QuickFix CodeActionKind = "quickfix" // line 13338 + // Base kind for refactoring actions: 'refactor' + Refactor CodeActionKind = "refactor" // line 13343 + // Base kind for refactoring extraction actions: 'refactor.extract' + // + // Example extract actions: + // + // + // - Extract method + // - Extract function + // - Extract variable + // - Extract interface from class + // - ... + RefactorExtract CodeActionKind = "refactor.extract" // line 13348 + // Base kind for refactoring inline actions: 'refactor.inline' + // + // Example inline actions: + // + // + // - Inline function + // - Inline variable + // - Inline constant + // - ... + RefactorInline CodeActionKind = "refactor.inline" // line 13353 + // Base kind for refactoring rewrite actions: 'refactor.rewrite' + // + // Example rewrite actions: + // + // + // - Convert JavaScript function to class + // - Add or remove parameter + // - Encapsulate field + // - Make method static + // - Move method to base class + // - ... + RefactorRewrite CodeActionKind = "refactor.rewrite" // line 13358 + // Base kind for source actions: `source` + // + // Source code actions apply to the entire file. + Source CodeActionKind = "source" // line 13363 + // Base kind for an organize imports source action: `source.organizeImports` + SourceOrganizeImports CodeActionKind = "source.organizeImports" // line 13368 + // Base kind for auto-fix source actions: `source.fixAll`. + // + // Fix all actions automatically fix errors that have a clear fix that do not require user input. + // They should not suppress errors or perform unsafe fixes such as generating new types or classes. + // + // @since 3.15.0 + SourceFixAll CodeActionKind = "source.fixAll" // line 13373 + // The reason why code actions were requested. + // + // @since 3.17.0 + // Code actions were explicitly requested by the user or by an extension. + CodeActionInvoked CodeActionTriggerKind = 1 // line 13613 + // Code actions were requested automatically. + // + // This typically happens when current selection in a file changes, but can + // also be triggered when file content changes. + CodeActionAutomatic CodeActionTriggerKind = 2 // line 13618 + // The kind of a completion entry. + TextCompletion CompletionItemKind = 1 // line 13141 + MethodCompletion CompletionItemKind = 2 // line 13145 + FunctionCompletion CompletionItemKind = 3 // line 13149 + ConstructorCompletion CompletionItemKind = 4 // line 13153 + FieldCompletion CompletionItemKind = 5 // line 13157 + VariableCompletion CompletionItemKind = 6 // line 13161 + ClassCompletion CompletionItemKind = 7 // line 13165 + InterfaceCompletion CompletionItemKind = 8 // line 13169 + ModuleCompletion CompletionItemKind = 9 // line 13173 + PropertyCompletion CompletionItemKind = 10 // line 13177 + UnitCompletion CompletionItemKind = 11 // line 13181 + ValueCompletion CompletionItemKind = 12 // line 13185 + EnumCompletion CompletionItemKind = 13 // line 13189 + KeywordCompletion CompletionItemKind = 14 // line 13193 + SnippetCompletion CompletionItemKind = 15 // line 13197 + ColorCompletion CompletionItemKind = 16 // line 13201 + FileCompletion CompletionItemKind = 17 // line 13205 + ReferenceCompletion CompletionItemKind = 18 // line 13209 + FolderCompletion CompletionItemKind = 19 // line 13213 + EnumMemberCompletion CompletionItemKind = 20 // line 13217 + ConstantCompletion CompletionItemKind = 21 // line 13221 + StructCompletion CompletionItemKind = 22 // line 13225 + EventCompletion CompletionItemKind = 23 // line 13229 + OperatorCompletion CompletionItemKind = 24 // line 13233 + TypeParameterCompletion CompletionItemKind = 25 // line 13237 + // Completion item tags are extra annotations that tweak the rendering of a completion + // item. + // + // @since 3.15.0 + // Render a completion as obsolete, usually using a strike-out. + ComplDeprecated CompletionItemTag = 1 // line 13251 + // How a completion was triggered + // Completion was triggered by typing an identifier (24x7 code + // complete), manual invocation (e.g Ctrl+Space) or via API. + Invoked CompletionTriggerKind = 1 // line 13562 + // Completion was triggered by a trigger character specified by + // the `triggerCharacters` properties of the `CompletionRegistrationOptions`. + TriggerCharacter CompletionTriggerKind = 2 // line 13567 + // Completion was re-triggered as current completion list is incomplete + TriggerForIncompleteCompletions CompletionTriggerKind = 3 // line 13572 + // The diagnostic's severity. + // Reports an error. + SeverityError DiagnosticSeverity = 1 // line 13511 + // Reports a warning. + SeverityWarning DiagnosticSeverity = 2 // line 13516 + // Reports an information. + SeverityInformation DiagnosticSeverity = 3 // line 13521 + // Reports a hint. + SeverityHint DiagnosticSeverity = 4 // line 13526 + // The diagnostic tags. + // + // @since 3.15.0 + // Unused or unnecessary code. + // + // Clients are allowed to render diagnostics with this tag faded out instead of having + // an error squiggle. + Unnecessary DiagnosticTag = 1 // line 13541 + // Deprecated or obsolete code. + // + // Clients are allowed to rendered diagnostics with this tag strike through. + Deprecated DiagnosticTag = 2 // line 13546 + // The document diagnostic report kinds. + // + // @since 3.17.0 + // A diagnostic report with a full + // set of problems. + DiagnosticFull DocumentDiagnosticReportKind = "full" // line 12729 + // A report indicating that the last + // returned report is still accurate. + DiagnosticUnchanged DocumentDiagnosticReportKind = "unchanged" // line 12734 + // A document highlight kind. + // A textual occurrence. + Text DocumentHighlightKind = 1 // line 13308 + // Read-access of a symbol, like reading a variable. + Read DocumentHighlightKind = 2 // line 13313 + // Write-access of a symbol, like writing to a variable. + Write DocumentHighlightKind = 3 // line 13318 + // Predefined error codes. + ParseError ErrorCodes = -32700 // line 12750 + InvalidRequest ErrorCodes = -32600 // line 12754 + MethodNotFound ErrorCodes = -32601 // line 12758 + InvalidParams ErrorCodes = -32602 // line 12762 + InternalError ErrorCodes = -32603 // line 12766 + // Error code indicating that a server received a notification or + // request before the server has received the `initialize` request. + ServerNotInitialized ErrorCodes = -32002 // line 12770 + UnknownErrorCode ErrorCodes = -32001 // line 12775 + // Applying the workspace change is simply aborted if one of the changes provided + // fails. All operations executed before the failing operation stay executed. + Abort FailureHandlingKind = "abort" // line 13700 + // All operations are executed transactional. That means they either all + // succeed or no changes at all are applied to the workspace. + Transactional FailureHandlingKind = "transactional" // line 13705 + // If the workspace edit contains only textual file changes they are executed transactional. + // If resource changes (create, rename or delete file) are part of the change the failure + // handling strategy is abort. + TextOnlyTransactional FailureHandlingKind = "textOnlyTransactional" // line 13710 + // The client tries to undo the operations already executed. But there is no + // guarantee that this is succeeding. + Undo FailureHandlingKind = "undo" // line 13715 + // The file event type + // The file got created. + Created FileChangeType = 1 // line 13461 + // The file got changed. + Changed FileChangeType = 2 // line 13466 + // The file got deleted. + Deleted FileChangeType = 3 // line 13471 + // A pattern kind describing if a glob pattern matches a file a folder or + // both. + // + // @since 3.16.0 + // The pattern matches a file only. + FilePattern FileOperationPatternKind = "file" // line 13634 + // The pattern matches a folder only. + FolderPattern FileOperationPatternKind = "folder" // line 13639 + // A set of predefined range kinds. + // Folding range for a comment + Comment FoldingRangeKind = "comment" // line 12822 + // Folding range for an import or include + Imports FoldingRangeKind = "imports" // line 12827 + // Folding range for a region (e.g. `#region`) + Region FoldingRangeKind = "region" // line 12832 + // Inlay hint kinds. + // + // @since 3.17.0 + // An inlay hint that for a type annotation. + Type InlayHintKind = 1 // line 13040 + // An inlay hint that is for a parameter. + Parameter InlayHintKind = 2 // line 13045 + // Defines whether the insert text in a completion item should be interpreted as + // plain text or a snippet. + // The primary text to be inserted is treated as a plain string. + PlainTextTextFormat InsertTextFormat = 1 // line 13267 + // The primary text to be inserted is treated as a snippet. + // + // A snippet can define tab stops and placeholders with `$1`, `$2` + // and `${3:foo}`. `$0` defines the final tab stop, it defaults to + // the end of the snippet. Placeholders with equal identifiers are linked, + // that is typing in one will update others too. + // + // See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax + SnippetTextFormat InsertTextFormat = 2 // line 13272 + // How whitespace and indentation is handled during completion + // item insertion. + // + // @since 3.16.0 + // The insertion or replace strings is taken as it is. If the + // value is multi line the lines below the cursor will be + // inserted using the indentation defined in the string value. + // The client will not apply any kind of adjustments to the + // string. + AsIs InsertTextMode = 1 // line 13287 + // The editor adjusts leading whitespace of new lines so that + // they match the indentation up to the cursor of the line for + // which the item is accepted. + // + // Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a + // multi line completion item is indented using 2 tabs and all + // following lines inserted will be indented using 2 tabs as well. + AdjustIndentation InsertTextMode = 2 // line 13292 + // A request failed but it was syntactically correct, e.g the + // method name was known and the parameters were valid. The error + // message should contain human readable information about why + // the request failed. + // + // @since 3.17.0 + RequestFailed LSPErrorCodes = -32803 // line 12790 + // The server cancelled the request. This error code should + // only be used for requests that explicitly support being + // server cancellable. + // + // @since 3.17.0 + ServerCancelled LSPErrorCodes = -32802 // line 12796 + // The server detected that the content of a document got + // modified outside normal conditions. A server should + // NOT send this error code if it detects a content change + // in it unprocessed messages. The result even computed + // on an older state might still be useful for the client. + // + // If a client decides that a result is not of any use anymore + // the client should cancel the request. + ContentModified LSPErrorCodes = -32801 // line 12802 + // The client has canceled a request and a server as detected + // the cancel. + RequestCancelled LSPErrorCodes = -32800 // line 12807 + // Describes the content type that a client supports in various + // result literals like `Hover`, `ParameterInfo` or `CompletionItem`. + // + // Please note that `MarkupKinds` must not start with a `$`. This kinds + // are reserved for internal usage. + // Plain text is supported as a content format + PlainText MarkupKind = "plaintext" // line 13414 + // Markdown is supported as a content format + Markdown MarkupKind = "markdown" // line 13419 + // The message type + // An error message. + Error MessageType = 1 // line 13061 + // A warning message. + Warning MessageType = 2 // line 13066 + // An information message. + Info MessageType = 3 // line 13071 + // A log message. + Log MessageType = 4 // line 13076 + // The moniker kind. + // + // @since 3.16.0 + // The moniker represent a symbol that is imported into a project + Import MonikerKind = "import" // line 13014 + // The moniker represents a symbol that is exported from a project + Export MonikerKind = "export" // line 13019 + // The moniker represents a symbol that is local to a project (e.g. a local + // variable of a function, a class not visible outside the project, ...) + Local MonikerKind = "local" // line 13024 + // A notebook cell kind. + // + // @since 3.17.0 + // A markup-cell is formatted source that is used for display. + Markup NotebookCellKind = 1 // line 13655 + // A code-cell is source code. + Code NotebookCellKind = 2 // line 13660 + // A set of predefined position encoding kinds. + // + // @since 3.17.0 + // Character offsets count UTF-8 code units. + UTF8 PositionEncodingKind = "utf-8" // line 13434 + // Character offsets count UTF-16 code units. + // + // This is the default and must always be supported + // by servers + UTF16 PositionEncodingKind = "utf-16" // line 13439 + // Character offsets count UTF-32 code units. + // + // Implementation note: these are the same as Unicode code points, + // so this `PositionEncodingKind` may also be used for an + // encoding-agnostic representation of character offsets. + UTF32 PositionEncodingKind = "utf-32" // line 13444 + // The client's default behavior is to select the identifier + // according the to language's syntax rule. + Identifier PrepareSupportDefaultBehavior = 1 // line 13729 + // Supports creating new files and folders. + Create ResourceOperationKind = "create" // line 13676 + // Supports renaming existing files and folders. + Rename ResourceOperationKind = "rename" // line 13681 + // Supports deleting existing files and folders. + Delete ResourceOperationKind = "delete" // line 13686 + // A set of predefined token modifiers. This set is not fixed + // an clients can specify additional token types via the + // corresponding client capabilities. + // + // @since 3.16.0 + ModDeclaration SemanticTokenModifiers = "declaration" // line 12677 + ModDefinition SemanticTokenModifiers = "definition" // line 12681 + ModReadonly SemanticTokenModifiers = "readonly" // line 12685 + ModStatic SemanticTokenModifiers = "static" // line 12689 + ModDeprecated SemanticTokenModifiers = "deprecated" // line 12693 + ModAbstract SemanticTokenModifiers = "abstract" // line 12697 + ModAsync SemanticTokenModifiers = "async" // line 12701 + ModModification SemanticTokenModifiers = "modification" // line 12705 + ModDocumentation SemanticTokenModifiers = "documentation" // line 12709 + ModDefaultLibrary SemanticTokenModifiers = "defaultLibrary" // line 12713 + // A set of predefined token types. This set is not fixed + // an clients can specify additional token types via the + // corresponding client capabilities. + // + // @since 3.16.0 + NamespaceType SemanticTokenTypes = "namespace" // line 12570 + // Represents a generic type. Acts as a fallback for types which can't be mapped to + // a specific type like class or enum. + TypeType SemanticTokenTypes = "type" // line 12574 + ClassType SemanticTokenTypes = "class" // line 12579 + EnumType SemanticTokenTypes = "enum" // line 12583 + InterfaceType SemanticTokenTypes = "interface" // line 12587 + StructType SemanticTokenTypes = "struct" // line 12591 + TypeParameterType SemanticTokenTypes = "typeParameter" // line 12595 + ParameterType SemanticTokenTypes = "parameter" // line 12599 + VariableType SemanticTokenTypes = "variable" // line 12603 + PropertyType SemanticTokenTypes = "property" // line 12607 + EnumMemberType SemanticTokenTypes = "enumMember" // line 12611 + EventType SemanticTokenTypes = "event" // line 12615 + FunctionType SemanticTokenTypes = "function" // line 12619 + MethodType SemanticTokenTypes = "method" // line 12623 + MacroType SemanticTokenTypes = "macro" // line 12627 + KeywordType SemanticTokenTypes = "keyword" // line 12631 + ModifierType SemanticTokenTypes = "modifier" // line 12635 + CommentType SemanticTokenTypes = "comment" // line 12639 + StringType SemanticTokenTypes = "string" // line 12643 + NumberType SemanticTokenTypes = "number" // line 12647 + RegexpType SemanticTokenTypes = "regexp" // line 12651 + OperatorType SemanticTokenTypes = "operator" // line 12655 + // @since 3.17.0 + DecoratorType SemanticTokenTypes = "decorator" // line 12659 + // How a signature help was triggered. + // + // @since 3.15.0 + // Signature help was invoked manually by the user or by a command. + SigInvoked SignatureHelpTriggerKind = 1 // line 13587 + // Signature help was triggered by a trigger character. + SigTriggerCharacter SignatureHelpTriggerKind = 2 // line 13592 + // Signature help was triggered by the cursor moving or by the document content changing. + SigContentChange SignatureHelpTriggerKind = 3 // line 13597 + // A symbol kind. + File SymbolKind = 1 // line 12848 + Module SymbolKind = 2 // line 12852 + Namespace SymbolKind = 3 // line 12856 + Package SymbolKind = 4 // line 12860 + Class SymbolKind = 5 // line 12864 + Method SymbolKind = 6 // line 12868 + Property SymbolKind = 7 // line 12872 + Field SymbolKind = 8 // line 12876 + Constructor SymbolKind = 9 // line 12880 + Enum SymbolKind = 10 // line 12884 + Interface SymbolKind = 11 // line 12888 + Function SymbolKind = 12 // line 12892 + Variable SymbolKind = 13 // line 12896 + Constant SymbolKind = 14 // line 12900 + String SymbolKind = 15 // line 12904 + Number SymbolKind = 16 // line 12908 + Boolean SymbolKind = 17 // line 12912 + Array SymbolKind = 18 // line 12916 + Object SymbolKind = 19 // line 12920 + Key SymbolKind = 20 // line 12924 + Null SymbolKind = 21 // line 12928 + EnumMember SymbolKind = 22 // line 12932 + Struct SymbolKind = 23 // line 12936 + Event SymbolKind = 24 // line 12940 + Operator SymbolKind = 25 // line 12944 + TypeParameter SymbolKind = 26 // line 12948 + // Symbol tags are extra annotations that tweak the rendering of a symbol. + // + // @since 3.16 + // Render a symbol as obsolete, usually using a strike-out. + DeprecatedSymbol SymbolTag = 1 // line 12962 + // Represents reasons why a text document is saved. + // Manually triggered, e.g. by the user pressing save, by starting debugging, + // or by an API call. + Manual TextDocumentSaveReason = 1 // line 13116 + // Automatic after a delay. + AfterDelay TextDocumentSaveReason = 2 // line 13121 + // When the editor lost focus. + FocusOut TextDocumentSaveReason = 3 // line 13126 + // Defines how the host (editor) should sync + // document changes to the language server. + // Documents should not be synced at all. + None TextDocumentSyncKind = 0 // line 13091 + // Documents are synced by always sending the full content + // of the document. + Full TextDocumentSyncKind = 1 // line 13096 + // Documents are synced by sending the full content on open. + // After that only incremental updates to the document are + // send. + Incremental TextDocumentSyncKind = 2 // line 13101 + Relative TokenFormat = "relative" // line 13743 + // Turn tracing off. + Off TraceValues = "off" // line 13390 + // Trace messages only. + Messages TraceValues = "messages" // line 13395 + // Verbose message tracing. + Verbose TraceValues = "verbose" // line 13400 + // Moniker uniqueness level to define scope of the moniker. + // + // @since 3.16.0 + // The moniker is only unique inside a document + Document UniquenessLevel = "document" // line 12978 + // The moniker is unique inside a project for which a dump got created + Project UniquenessLevel = "project" // line 12983 + // The moniker is unique inside the group to which a project belongs + Group UniquenessLevel = "group" // line 12988 + // The moniker is unique inside the moniker scheme. + Scheme UniquenessLevel = "scheme" // line 12993 + // The moniker is globally unique + Global UniquenessLevel = "global" // line 12998 + // Interested in create events. + WatchCreate WatchKind = 1 // line 13486 + // Interested in change events + WatchChange WatchKind = 2 // line 13491 + // Interested in delete events + WatchDelete WatchKind = 4 // line 13496 +) diff --git a/gopls/internal/lsp/protocol/tsserver.go b/gopls/internal/lsp/protocol/tsserver.go new file mode 100644 index 000000000..e02e1fdb9 --- /dev/null +++ b/gopls/internal/lsp/protocol/tsserver.go @@ -0,0 +1,1160 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated for LSP. DO NOT EDIT. + +package protocol + +// Code generated from protocol/metaModel.json at ref release/protocol/3.17.3-next.6 (hash 56c23c557e3568a9f56f42435fd5a80f9458957f). +// https://github.com/microsoft/vscode-languageserver-node/blob/release/protocol/3.17.3-next.6/protocol/metaModel.json +// LSP metaData.version = 3.17.0. + +import ( + "context" + "encoding/json" + + "golang.org/x/tools/internal/jsonrpc2" +) + +type Server interface { + Progress(context.Context, *ProgressParams) error // $/progress + SetTrace(context.Context, *SetTraceParams) error // $/setTrace + IncomingCalls(context.Context, *CallHierarchyIncomingCallsParams) ([]CallHierarchyIncomingCall, error) // callHierarchy/incomingCalls + OutgoingCalls(context.Context, *CallHierarchyOutgoingCallsParams) ([]CallHierarchyOutgoingCall, error) // callHierarchy/outgoingCalls + ResolveCodeAction(context.Context, *CodeAction) (*CodeAction, error) // codeAction/resolve + ResolveCodeLens(context.Context, *CodeLens) (*CodeLens, error) // codeLens/resolve + ResolveCompletionItem(context.Context, *CompletionItem) (*CompletionItem, error) // completionItem/resolve + ResolveDocumentLink(context.Context, *DocumentLink) (*DocumentLink, error) // documentLink/resolve + Exit(context.Context) error // exit + Initialize(context.Context, *ParamInitialize) (*InitializeResult, error) // initialize + Initialized(context.Context, *InitializedParams) error // initialized + Resolve(context.Context, *InlayHint) (*InlayHint, error) // inlayHint/resolve + DidChangeNotebookDocument(context.Context, *DidChangeNotebookDocumentParams) error // notebookDocument/didChange + DidCloseNotebookDocument(context.Context, *DidCloseNotebookDocumentParams) error // notebookDocument/didClose + DidOpenNotebookDocument(context.Context, *DidOpenNotebookDocumentParams) error // notebookDocument/didOpen + DidSaveNotebookDocument(context.Context, *DidSaveNotebookDocumentParams) error // notebookDocument/didSave + Shutdown(context.Context) error // shutdown + CodeAction(context.Context, *CodeActionParams) ([]CodeAction, error) // textDocument/codeAction + CodeLens(context.Context, *CodeLensParams) ([]CodeLens, error) // textDocument/codeLens + ColorPresentation(context.Context, *ColorPresentationParams) ([]ColorPresentation, error) // textDocument/colorPresentation + Completion(context.Context, *CompletionParams) (*CompletionList, error) // textDocument/completion + Declaration(context.Context, *DeclarationParams) (*Or_textDocument_declaration, error) // textDocument/declaration + Definition(context.Context, *DefinitionParams) ([]Location, error) // textDocument/definition + Diagnostic(context.Context, *string) (*string, error) // textDocument/diagnostic + DidChange(context.Context, *DidChangeTextDocumentParams) error // textDocument/didChange + DidClose(context.Context, *DidCloseTextDocumentParams) error // textDocument/didClose + DidOpen(context.Context, *DidOpenTextDocumentParams) error // textDocument/didOpen + DidSave(context.Context, *DidSaveTextDocumentParams) error // textDocument/didSave + DocumentColor(context.Context, *DocumentColorParams) ([]ColorInformation, error) // textDocument/documentColor + DocumentHighlight(context.Context, *DocumentHighlightParams) ([]DocumentHighlight, error) // textDocument/documentHighlight + DocumentLink(context.Context, *DocumentLinkParams) ([]DocumentLink, error) // textDocument/documentLink + DocumentSymbol(context.Context, *DocumentSymbolParams) ([]interface{}, error) // textDocument/documentSymbol + FoldingRange(context.Context, *FoldingRangeParams) ([]FoldingRange, error) // textDocument/foldingRange + Formatting(context.Context, *DocumentFormattingParams) ([]TextEdit, error) // textDocument/formatting + Hover(context.Context, *HoverParams) (*Hover, error) // textDocument/hover + Implementation(context.Context, *ImplementationParams) ([]Location, error) // textDocument/implementation + InlayHint(context.Context, *InlayHintParams) ([]InlayHint, error) // textDocument/inlayHint + InlineValue(context.Context, *InlineValueParams) ([]InlineValue, error) // textDocument/inlineValue + LinkedEditingRange(context.Context, *LinkedEditingRangeParams) (*LinkedEditingRanges, error) // textDocument/linkedEditingRange + Moniker(context.Context, *MonikerParams) ([]Moniker, error) // textDocument/moniker + OnTypeFormatting(context.Context, *DocumentOnTypeFormattingParams) ([]TextEdit, error) // textDocument/onTypeFormatting + PrepareCallHierarchy(context.Context, *CallHierarchyPrepareParams) ([]CallHierarchyItem, error) // textDocument/prepareCallHierarchy + PrepareRename(context.Context, *PrepareRenameParams) (*PrepareRename2Gn, error) // textDocument/prepareRename + PrepareTypeHierarchy(context.Context, *TypeHierarchyPrepareParams) ([]TypeHierarchyItem, error) // textDocument/prepareTypeHierarchy + RangeFormatting(context.Context, *DocumentRangeFormattingParams) ([]TextEdit, error) // textDocument/rangeFormatting + References(context.Context, *ReferenceParams) ([]Location, error) // textDocument/references + Rename(context.Context, *RenameParams) (*WorkspaceEdit, error) // textDocument/rename + SelectionRange(context.Context, *SelectionRangeParams) ([]SelectionRange, error) // textDocument/selectionRange + SemanticTokensFull(context.Context, *SemanticTokensParams) (*SemanticTokens, error) // textDocument/semanticTokens/full + SemanticTokensFullDelta(context.Context, *SemanticTokensDeltaParams) (interface{}, error) // textDocument/semanticTokens/full/delta + SemanticTokensRange(context.Context, *SemanticTokensRangeParams) (*SemanticTokens, error) // textDocument/semanticTokens/range + SignatureHelp(context.Context, *SignatureHelpParams) (*SignatureHelp, error) // textDocument/signatureHelp + TypeDefinition(context.Context, *TypeDefinitionParams) ([]Location, error) // textDocument/typeDefinition + WillSave(context.Context, *WillSaveTextDocumentParams) error // textDocument/willSave + WillSaveWaitUntil(context.Context, *WillSaveTextDocumentParams) ([]TextEdit, error) // textDocument/willSaveWaitUntil + Subtypes(context.Context, *TypeHierarchySubtypesParams) ([]TypeHierarchyItem, error) // typeHierarchy/subtypes + Supertypes(context.Context, *TypeHierarchySupertypesParams) ([]TypeHierarchyItem, error) // typeHierarchy/supertypes + WorkDoneProgressCancel(context.Context, *WorkDoneProgressCancelParams) error // window/workDoneProgress/cancel + DiagnosticWorkspace(context.Context, *WorkspaceDiagnosticParams) (*WorkspaceDiagnosticReport, error) // workspace/diagnostic + DidChangeConfiguration(context.Context, *DidChangeConfigurationParams) error // workspace/didChangeConfiguration + DidChangeWatchedFiles(context.Context, *DidChangeWatchedFilesParams) error // workspace/didChangeWatchedFiles + DidChangeWorkspaceFolders(context.Context, *DidChangeWorkspaceFoldersParams) error // workspace/didChangeWorkspaceFolders + DidCreateFiles(context.Context, *CreateFilesParams) error // workspace/didCreateFiles + DidDeleteFiles(context.Context, *DeleteFilesParams) error // workspace/didDeleteFiles + DidRenameFiles(context.Context, *RenameFilesParams) error // workspace/didRenameFiles + ExecuteCommand(context.Context, *ExecuteCommandParams) (interface{}, error) // workspace/executeCommand + Symbol(context.Context, *WorkspaceSymbolParams) ([]SymbolInformation, error) // workspace/symbol + WillCreateFiles(context.Context, *CreateFilesParams) (*WorkspaceEdit, error) // workspace/willCreateFiles + WillDeleteFiles(context.Context, *DeleteFilesParams) (*WorkspaceEdit, error) // workspace/willDeleteFiles + WillRenameFiles(context.Context, *RenameFilesParams) (*WorkspaceEdit, error) // workspace/willRenameFiles + ResolveWorkspaceSymbol(context.Context, *WorkspaceSymbol) (*WorkspaceSymbol, error) // workspaceSymbol/resolve + NonstandardRequest(ctx context.Context, method string, params interface{}) (interface{}, error) +} + +func serverDispatch(ctx context.Context, server Server, reply jsonrpc2.Replier, r jsonrpc2.Request) (bool, error) { + switch r.Method() { + case "$/progress": + var params ProgressParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.Progress(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "$/setTrace": + var params SetTraceParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.SetTrace(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "callHierarchy/incomingCalls": + var params CallHierarchyIncomingCallsParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.IncomingCalls(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "callHierarchy/outgoingCalls": + var params CallHierarchyOutgoingCallsParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.OutgoingCalls(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "codeAction/resolve": + var params CodeAction + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ResolveCodeAction(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "codeLens/resolve": + var params CodeLens + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ResolveCodeLens(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "completionItem/resolve": + var params CompletionItem + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ResolveCompletionItem(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "documentLink/resolve": + var params DocumentLink + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ResolveDocumentLink(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "exit": + err := server.Exit(ctx) + return true, reply(ctx, nil, err) + case "initialize": + var params ParamInitialize + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Initialize(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "initialized": + var params InitializedParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.Initialized(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "inlayHint/resolve": + var params InlayHint + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Resolve(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "notebookDocument/didChange": + var params DidChangeNotebookDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidChangeNotebookDocument(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "notebookDocument/didClose": + var params DidCloseNotebookDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidCloseNotebookDocument(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "notebookDocument/didOpen": + var params DidOpenNotebookDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidOpenNotebookDocument(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "notebookDocument/didSave": + var params DidSaveNotebookDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidSaveNotebookDocument(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "shutdown": + err := server.Shutdown(ctx) + return true, reply(ctx, nil, err) + case "textDocument/codeAction": + var params CodeActionParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.CodeAction(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/codeLens": + var params CodeLensParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.CodeLens(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/colorPresentation": + var params ColorPresentationParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ColorPresentation(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/completion": + var params CompletionParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Completion(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/declaration": + var params DeclarationParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Declaration(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/definition": + var params DefinitionParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Definition(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/diagnostic": + var params string + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Diagnostic(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/didChange": + var params DidChangeTextDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidChange(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "textDocument/didClose": + var params DidCloseTextDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidClose(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "textDocument/didOpen": + var params DidOpenTextDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidOpen(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "textDocument/didSave": + var params DidSaveTextDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidSave(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "textDocument/documentColor": + var params DocumentColorParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.DocumentColor(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/documentHighlight": + var params DocumentHighlightParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.DocumentHighlight(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/documentLink": + var params DocumentLinkParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.DocumentLink(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/documentSymbol": + var params DocumentSymbolParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.DocumentSymbol(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/foldingRange": + var params FoldingRangeParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.FoldingRange(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/formatting": + var params DocumentFormattingParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Formatting(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/hover": + var params HoverParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Hover(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/implementation": + var params ImplementationParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Implementation(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/inlayHint": + var params InlayHintParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.InlayHint(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/inlineValue": + var params InlineValueParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.InlineValue(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/linkedEditingRange": + var params LinkedEditingRangeParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.LinkedEditingRange(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/moniker": + var params MonikerParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Moniker(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/onTypeFormatting": + var params DocumentOnTypeFormattingParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.OnTypeFormatting(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/prepareCallHierarchy": + var params CallHierarchyPrepareParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.PrepareCallHierarchy(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/prepareRename": + var params PrepareRenameParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.PrepareRename(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/prepareTypeHierarchy": + var params TypeHierarchyPrepareParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.PrepareTypeHierarchy(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/rangeFormatting": + var params DocumentRangeFormattingParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.RangeFormatting(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/references": + var params ReferenceParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.References(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/rename": + var params RenameParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Rename(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/selectionRange": + var params SelectionRangeParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.SelectionRange(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/semanticTokens/full": + var params SemanticTokensParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.SemanticTokensFull(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/semanticTokens/full/delta": + var params SemanticTokensDeltaParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.SemanticTokensFullDelta(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/semanticTokens/range": + var params SemanticTokensRangeParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.SemanticTokensRange(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/signatureHelp": + var params SignatureHelpParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.SignatureHelp(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/typeDefinition": + var params TypeDefinitionParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.TypeDefinition(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "textDocument/willSave": + var params WillSaveTextDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.WillSave(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "textDocument/willSaveWaitUntil": + var params WillSaveTextDocumentParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.WillSaveWaitUntil(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "typeHierarchy/subtypes": + var params TypeHierarchySubtypesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Subtypes(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "typeHierarchy/supertypes": + var params TypeHierarchySupertypesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Supertypes(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "window/workDoneProgress/cancel": + var params WorkDoneProgressCancelParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.WorkDoneProgressCancel(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/diagnostic": + var params WorkspaceDiagnosticParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.DiagnosticWorkspace(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/didChangeConfiguration": + var params DidChangeConfigurationParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidChangeConfiguration(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/didChangeWatchedFiles": + var params DidChangeWatchedFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidChangeWatchedFiles(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/didChangeWorkspaceFolders": + var params DidChangeWorkspaceFoldersParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidChangeWorkspaceFolders(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/didCreateFiles": + var params CreateFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidCreateFiles(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/didDeleteFiles": + var params DeleteFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidDeleteFiles(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/didRenameFiles": + var params RenameFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + err := server.DidRenameFiles(ctx, ¶ms) + return true, reply(ctx, nil, err) + case "workspace/executeCommand": + var params ExecuteCommandParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ExecuteCommand(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/symbol": + var params WorkspaceSymbolParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.Symbol(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/willCreateFiles": + var params CreateFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.WillCreateFiles(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/willDeleteFiles": + var params DeleteFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.WillDeleteFiles(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspace/willRenameFiles": + var params RenameFilesParams + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.WillRenameFiles(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + case "workspaceSymbol/resolve": + var params WorkspaceSymbol + if err := json.Unmarshal(r.Params(), ¶ms); err != nil { + return true, sendParseError(ctx, reply, err) + } + resp, err := server.ResolveWorkspaceSymbol(ctx, ¶ms) + if err != nil { + return true, reply(ctx, nil, err) + } + return true, reply(ctx, resp, nil) + default: + return false, nil + } +} + +func (s *serverDispatcher) Progress(ctx context.Context, params *ProgressParams) error { + return s.sender.Notify(ctx, "$/progress", params) +} +func (s *serverDispatcher) SetTrace(ctx context.Context, params *SetTraceParams) error { + return s.sender.Notify(ctx, "$/setTrace", params) +} +func (s *serverDispatcher) IncomingCalls(ctx context.Context, params *CallHierarchyIncomingCallsParams) ([]CallHierarchyIncomingCall, error) { + var result []CallHierarchyIncomingCall + if err := s.sender.Call(ctx, "callHierarchy/incomingCalls", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) OutgoingCalls(ctx context.Context, params *CallHierarchyOutgoingCallsParams) ([]CallHierarchyOutgoingCall, error) { + var result []CallHierarchyOutgoingCall + if err := s.sender.Call(ctx, "callHierarchy/outgoingCalls", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) ResolveCodeAction(ctx context.Context, params *CodeAction) (*CodeAction, error) { + var result *CodeAction + if err := s.sender.Call(ctx, "codeAction/resolve", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) ResolveCodeLens(ctx context.Context, params *CodeLens) (*CodeLens, error) { + var result *CodeLens + if err := s.sender.Call(ctx, "codeLens/resolve", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) ResolveCompletionItem(ctx context.Context, params *CompletionItem) (*CompletionItem, error) { + var result *CompletionItem + if err := s.sender.Call(ctx, "completionItem/resolve", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) ResolveDocumentLink(ctx context.Context, params *DocumentLink) (*DocumentLink, error) { + var result *DocumentLink + if err := s.sender.Call(ctx, "documentLink/resolve", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Exit(ctx context.Context) error { + return s.sender.Notify(ctx, "exit", nil) +} +func (s *serverDispatcher) Initialize(ctx context.Context, params *ParamInitialize) (*InitializeResult, error) { + var result *InitializeResult + if err := s.sender.Call(ctx, "initialize", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Initialized(ctx context.Context, params *InitializedParams) error { + return s.sender.Notify(ctx, "initialized", params) +} +func (s *serverDispatcher) Resolve(ctx context.Context, params *InlayHint) (*InlayHint, error) { + var result *InlayHint + if err := s.sender.Call(ctx, "inlayHint/resolve", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) DidChangeNotebookDocument(ctx context.Context, params *DidChangeNotebookDocumentParams) error { + return s.sender.Notify(ctx, "notebookDocument/didChange", params) +} +func (s *serverDispatcher) DidCloseNotebookDocument(ctx context.Context, params *DidCloseNotebookDocumentParams) error { + return s.sender.Notify(ctx, "notebookDocument/didClose", params) +} +func (s *serverDispatcher) DidOpenNotebookDocument(ctx context.Context, params *DidOpenNotebookDocumentParams) error { + return s.sender.Notify(ctx, "notebookDocument/didOpen", params) +} +func (s *serverDispatcher) DidSaveNotebookDocument(ctx context.Context, params *DidSaveNotebookDocumentParams) error { + return s.sender.Notify(ctx, "notebookDocument/didSave", params) +} +func (s *serverDispatcher) Shutdown(ctx context.Context) error { + return s.sender.Call(ctx, "shutdown", nil, nil) +} +func (s *serverDispatcher) CodeAction(ctx context.Context, params *CodeActionParams) ([]CodeAction, error) { + var result []CodeAction + if err := s.sender.Call(ctx, "textDocument/codeAction", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) CodeLens(ctx context.Context, params *CodeLensParams) ([]CodeLens, error) { + var result []CodeLens + if err := s.sender.Call(ctx, "textDocument/codeLens", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) ColorPresentation(ctx context.Context, params *ColorPresentationParams) ([]ColorPresentation, error) { + var result []ColorPresentation + if err := s.sender.Call(ctx, "textDocument/colorPresentation", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Completion(ctx context.Context, params *CompletionParams) (*CompletionList, error) { + var result *CompletionList + if err := s.sender.Call(ctx, "textDocument/completion", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Declaration(ctx context.Context, params *DeclarationParams) (*Or_textDocument_declaration, error) { + var result *Or_textDocument_declaration + if err := s.sender.Call(ctx, "textDocument/declaration", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Definition(ctx context.Context, params *DefinitionParams) ([]Location, error) { + var result []Location + if err := s.sender.Call(ctx, "textDocument/definition", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Diagnostic(ctx context.Context, params *string) (*string, error) { + var result *string + if err := s.sender.Call(ctx, "textDocument/diagnostic", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) DidChange(ctx context.Context, params *DidChangeTextDocumentParams) error { + return s.sender.Notify(ctx, "textDocument/didChange", params) +} +func (s *serverDispatcher) DidClose(ctx context.Context, params *DidCloseTextDocumentParams) error { + return s.sender.Notify(ctx, "textDocument/didClose", params) +} +func (s *serverDispatcher) DidOpen(ctx context.Context, params *DidOpenTextDocumentParams) error { + return s.sender.Notify(ctx, "textDocument/didOpen", params) +} +func (s *serverDispatcher) DidSave(ctx context.Context, params *DidSaveTextDocumentParams) error { + return s.sender.Notify(ctx, "textDocument/didSave", params) +} +func (s *serverDispatcher) DocumentColor(ctx context.Context, params *DocumentColorParams) ([]ColorInformation, error) { + var result []ColorInformation + if err := s.sender.Call(ctx, "textDocument/documentColor", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) DocumentHighlight(ctx context.Context, params *DocumentHighlightParams) ([]DocumentHighlight, error) { + var result []DocumentHighlight + if err := s.sender.Call(ctx, "textDocument/documentHighlight", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) DocumentLink(ctx context.Context, params *DocumentLinkParams) ([]DocumentLink, error) { + var result []DocumentLink + if err := s.sender.Call(ctx, "textDocument/documentLink", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) DocumentSymbol(ctx context.Context, params *DocumentSymbolParams) ([]interface{}, error) { + var result []interface{} + if err := s.sender.Call(ctx, "textDocument/documentSymbol", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) FoldingRange(ctx context.Context, params *FoldingRangeParams) ([]FoldingRange, error) { + var result []FoldingRange + if err := s.sender.Call(ctx, "textDocument/foldingRange", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Formatting(ctx context.Context, params *DocumentFormattingParams) ([]TextEdit, error) { + var result []TextEdit + if err := s.sender.Call(ctx, "textDocument/formatting", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Hover(ctx context.Context, params *HoverParams) (*Hover, error) { + var result *Hover + if err := s.sender.Call(ctx, "textDocument/hover", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Implementation(ctx context.Context, params *ImplementationParams) ([]Location, error) { + var result []Location + if err := s.sender.Call(ctx, "textDocument/implementation", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) InlayHint(ctx context.Context, params *InlayHintParams) ([]InlayHint, error) { + var result []InlayHint + if err := s.sender.Call(ctx, "textDocument/inlayHint", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) InlineValue(ctx context.Context, params *InlineValueParams) ([]InlineValue, error) { + var result []InlineValue + if err := s.sender.Call(ctx, "textDocument/inlineValue", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) LinkedEditingRange(ctx context.Context, params *LinkedEditingRangeParams) (*LinkedEditingRanges, error) { + var result *LinkedEditingRanges + if err := s.sender.Call(ctx, "textDocument/linkedEditingRange", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Moniker(ctx context.Context, params *MonikerParams) ([]Moniker, error) { + var result []Moniker + if err := s.sender.Call(ctx, "textDocument/moniker", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) OnTypeFormatting(ctx context.Context, params *DocumentOnTypeFormattingParams) ([]TextEdit, error) { + var result []TextEdit + if err := s.sender.Call(ctx, "textDocument/onTypeFormatting", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) PrepareCallHierarchy(ctx context.Context, params *CallHierarchyPrepareParams) ([]CallHierarchyItem, error) { + var result []CallHierarchyItem + if err := s.sender.Call(ctx, "textDocument/prepareCallHierarchy", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) PrepareRename(ctx context.Context, params *PrepareRenameParams) (*PrepareRename2Gn, error) { + var result *PrepareRename2Gn + if err := s.sender.Call(ctx, "textDocument/prepareRename", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) PrepareTypeHierarchy(ctx context.Context, params *TypeHierarchyPrepareParams) ([]TypeHierarchyItem, error) { + var result []TypeHierarchyItem + if err := s.sender.Call(ctx, "textDocument/prepareTypeHierarchy", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) RangeFormatting(ctx context.Context, params *DocumentRangeFormattingParams) ([]TextEdit, error) { + var result []TextEdit + if err := s.sender.Call(ctx, "textDocument/rangeFormatting", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) References(ctx context.Context, params *ReferenceParams) ([]Location, error) { + var result []Location + if err := s.sender.Call(ctx, "textDocument/references", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Rename(ctx context.Context, params *RenameParams) (*WorkspaceEdit, error) { + var result *WorkspaceEdit + if err := s.sender.Call(ctx, "textDocument/rename", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) SelectionRange(ctx context.Context, params *SelectionRangeParams) ([]SelectionRange, error) { + var result []SelectionRange + if err := s.sender.Call(ctx, "textDocument/selectionRange", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) SemanticTokensFull(ctx context.Context, params *SemanticTokensParams) (*SemanticTokens, error) { + var result *SemanticTokens + if err := s.sender.Call(ctx, "textDocument/semanticTokens/full", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) SemanticTokensFullDelta(ctx context.Context, params *SemanticTokensDeltaParams) (interface{}, error) { + var result interface{} + if err := s.sender.Call(ctx, "textDocument/semanticTokens/full/delta", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) SemanticTokensRange(ctx context.Context, params *SemanticTokensRangeParams) (*SemanticTokens, error) { + var result *SemanticTokens + if err := s.sender.Call(ctx, "textDocument/semanticTokens/range", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) SignatureHelp(ctx context.Context, params *SignatureHelpParams) (*SignatureHelp, error) { + var result *SignatureHelp + if err := s.sender.Call(ctx, "textDocument/signatureHelp", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) TypeDefinition(ctx context.Context, params *TypeDefinitionParams) ([]Location, error) { + var result []Location + if err := s.sender.Call(ctx, "textDocument/typeDefinition", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) WillSave(ctx context.Context, params *WillSaveTextDocumentParams) error { + return s.sender.Notify(ctx, "textDocument/willSave", params) +} +func (s *serverDispatcher) WillSaveWaitUntil(ctx context.Context, params *WillSaveTextDocumentParams) ([]TextEdit, error) { + var result []TextEdit + if err := s.sender.Call(ctx, "textDocument/willSaveWaitUntil", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Subtypes(ctx context.Context, params *TypeHierarchySubtypesParams) ([]TypeHierarchyItem, error) { + var result []TypeHierarchyItem + if err := s.sender.Call(ctx, "typeHierarchy/subtypes", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Supertypes(ctx context.Context, params *TypeHierarchySupertypesParams) ([]TypeHierarchyItem, error) { + var result []TypeHierarchyItem + if err := s.sender.Call(ctx, "typeHierarchy/supertypes", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) WorkDoneProgressCancel(ctx context.Context, params *WorkDoneProgressCancelParams) error { + return s.sender.Notify(ctx, "window/workDoneProgress/cancel", params) +} +func (s *serverDispatcher) DiagnosticWorkspace(ctx context.Context, params *WorkspaceDiagnosticParams) (*WorkspaceDiagnosticReport, error) { + var result *WorkspaceDiagnosticReport + if err := s.sender.Call(ctx, "workspace/diagnostic", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) DidChangeConfiguration(ctx context.Context, params *DidChangeConfigurationParams) error { + return s.sender.Notify(ctx, "workspace/didChangeConfiguration", params) +} +func (s *serverDispatcher) DidChangeWatchedFiles(ctx context.Context, params *DidChangeWatchedFilesParams) error { + return s.sender.Notify(ctx, "workspace/didChangeWatchedFiles", params) +} +func (s *serverDispatcher) DidChangeWorkspaceFolders(ctx context.Context, params *DidChangeWorkspaceFoldersParams) error { + return s.sender.Notify(ctx, "workspace/didChangeWorkspaceFolders", params) +} +func (s *serverDispatcher) DidCreateFiles(ctx context.Context, params *CreateFilesParams) error { + return s.sender.Notify(ctx, "workspace/didCreateFiles", params) +} +func (s *serverDispatcher) DidDeleteFiles(ctx context.Context, params *DeleteFilesParams) error { + return s.sender.Notify(ctx, "workspace/didDeleteFiles", params) +} +func (s *serverDispatcher) DidRenameFiles(ctx context.Context, params *RenameFilesParams) error { + return s.sender.Notify(ctx, "workspace/didRenameFiles", params) +} +func (s *serverDispatcher) ExecuteCommand(ctx context.Context, params *ExecuteCommandParams) (interface{}, error) { + var result interface{} + if err := s.sender.Call(ctx, "workspace/executeCommand", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) Symbol(ctx context.Context, params *WorkspaceSymbolParams) ([]SymbolInformation, error) { + var result []SymbolInformation + if err := s.sender.Call(ctx, "workspace/symbol", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) WillCreateFiles(ctx context.Context, params *CreateFilesParams) (*WorkspaceEdit, error) { + var result *WorkspaceEdit + if err := s.sender.Call(ctx, "workspace/willCreateFiles", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) WillDeleteFiles(ctx context.Context, params *DeleteFilesParams) (*WorkspaceEdit, error) { + var result *WorkspaceEdit + if err := s.sender.Call(ctx, "workspace/willDeleteFiles", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) WillRenameFiles(ctx context.Context, params *RenameFilesParams) (*WorkspaceEdit, error) { + var result *WorkspaceEdit + if err := s.sender.Call(ctx, "workspace/willRenameFiles", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) ResolveWorkspaceSymbol(ctx context.Context, params *WorkspaceSymbol) (*WorkspaceSymbol, error) { + var result *WorkspaceSymbol + if err := s.sender.Call(ctx, "workspaceSymbol/resolve", params, &result); err != nil { + return nil, err + } + return result, nil +} +func (s *serverDispatcher) NonstandardRequest(ctx context.Context, method string, params interface{}) (interface{}, error) { + var result interface{} + if err := s.sender.Call(ctx, method, params, &result); err != nil { + return nil, err + } + return result, nil +} |