From de5a73fa86d3c076ad416dbabfa7b545b9e3b205 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 11:11:10 -0800 Subject: [PATCH 1/8] script to generate --- internal/lsp/lsproto/_generate/generate.mts | 136 ++ internal/lsp/lsproto/lsp_generated.go | 1344 +++++++++++++++++++ internal/lsp/server.go | 34 +- 3 files changed, 1493 insertions(+), 21 deletions(-) diff --git a/internal/lsp/lsproto/_generate/generate.mts b/internal/lsp/lsproto/_generate/generate.mts index 1828abd62f..dfdf26c95e 100644 --- a/internal/lsp/lsproto/_generate/generate.mts +++ b/internal/lsp/lsproto/_generate/generate.mts @@ -10,6 +10,7 @@ import type { Notification, OrType, Property, + ReferenceType, Request, Structure, Type, @@ -471,6 +472,107 @@ function generateCode() { parts.push(s + "\n"); } + function generateFinalizedStruct(structure: Structure, indent: string = "\t"): string[] { + const lines: string[] = []; + + for (const prop of structure.properties) { + const type = resolveType(prop.type); + + // For reference types that are structures, use a named finalized type + if (prop.type.kind === "reference") { + const refStructure = model.structures.find(s => s.name === type.name); + if (refStructure) { + // Use a named type for the finalized version + lines.push(`${indent}${titleCase(prop.name)} Finalized${type.name}`); + continue; + } + } + + // For other types (primitives, enums, arrays, etc.), use the type directly (no pointer) + const goType = type.name; + lines.push(`${indent}${titleCase(prop.name)} ${goType}`); + } + + return lines; + } + + function generateFinalizeConversion(structure: Structure, varName: string, indent: string): string[] { + const lines: string[] = []; + + for (const prop of structure.properties) { + const type = resolveType(prop.type); + const fieldName = titleCase(prop.name); + const accessPath = `${varName}.${fieldName}`; + + // For reference types that are structures, call the finalize function + if (prop.type.kind === "reference") { + const refStructure = model.structures.find(s => s.name === type.name); + if (refStructure) { + // Use lowercase (unexported) function name for helper functions + lines.push(`${indent}${fieldName}: finalize${type.name}(${accessPath}),`); + continue; + } + } + + // For other types, dereference if pointer + if (prop.optional || type.needsPointer) { + lines.push(`${indent}${fieldName}: derefOr(${accessPath}),`); + } + else { + lines.push(`${indent}${fieldName}: ${accessPath},`); + } + } + + return lines; + } + + function collectStructureDependencies(structure: Structure, visited = new Set()): Structure[] { + if (visited.has(structure.name)) { + return []; + } + visited.add(structure.name); + + const deps: Structure[] = []; + + for (const prop of structure.properties) { + if (prop.type.kind === "reference") { + const refStructure = model.structures.find(s => s.name === (prop.type as ReferenceType).name); + if (refStructure) { + deps.push(...collectStructureDependencies(refStructure, new Set(visited))); + deps.push(refStructure); + } + } + } + + return deps; + } + + function generateFinalizedTypeAndHelper(structure: Structure, isMain: boolean = false): string[] { + const lines: string[] = []; + const typeName = `Finalized${structure.name}`; + // Main function is exported, helpers are unexported + const funcName = isMain ? `Finalize${structure.name}` : `finalize${structure.name}`; + + // Generate the finalized type + lines.push(`type ${typeName} struct {`); + lines.push(...generateFinalizedStruct(structure, "\t")); + lines.push(`}`); + lines.push(``); + + // Generate the conversion function + lines.push(`func ${funcName}(v *${structure.name}) ${typeName} {`); + lines.push(`\tif v == nil {`); + lines.push(`\t\treturn ${typeName}{}`); + lines.push(`\t}`); + lines.push(`\treturn ${typeName}{`); + lines.push(...generateFinalizeConversion(structure, "v", "\t\t")); + lines.push(`\t}`); + lines.push(`}`); + lines.push(``); + + return lines; + } + // File header writeLine("// Code generated by generate.mts; DO NOT EDIT."); writeLine(""); @@ -877,6 +979,40 @@ function generateCode() { writeLine(""); } + // Generate finalized capabilities + const clientCapsStructure = model.structures.find(s => s.name === "ClientCapabilities"); + if (clientCapsStructure) { + writeLine("// Helper function for dereferencing pointers with zero value fallback"); + writeLine("func derefOr[T any](v *T) T {"); + writeLine("\tif v != nil {"); + writeLine("\t\treturn *v"); + writeLine("\t}"); + writeLine("\tvar zero T"); + writeLine("\treturn zero"); + writeLine("}"); + writeLine(""); + + // Collect all dependent structures and generate their finalized types + const deps = collectStructureDependencies(clientCapsStructure); + const uniqueDeps = Array.from(new Map(deps.map(d => [d.name, d])).values()); + + for (const dep of uniqueDeps) { + const depLines = generateFinalizedTypeAndHelper(dep, false); + for (const line of depLines) { + writeLine(line); + } + } + + // Generate the main FinalizedClientCapabilities type and function + writeLine("// FinalizedClientCapabilities is a version of ClientCapabilities where all nested"); + writeLine("// fields are values (not pointers), making it easier to access deeply nested capabilities."); + writeLine("// Use FinalizeClientCapabilities to convert from ClientCapabilities."); + const mainLines = generateFinalizedTypeAndHelper(clientCapsStructure, true); + for (const line of mainLines) { + writeLine(line); + } + } + return parts.join(""); } diff --git a/internal/lsp/lsproto/lsp_generated.go b/internal/lsp/lsproto/lsp_generated.go index 04892d51b9..dcd5e4a533 100644 --- a/internal/lsp/lsproto/lsp_generated.go +++ b/internal/lsp/lsproto/lsp_generated.go @@ -25725,3 +25725,1347 @@ func (o *StringLiteralSnippet) UnmarshalJSONFrom(dec *jsontext.Decoder) error { } return nil } + +// Helper function for dereferencing pointers with zero value fallback +func derefOr[T any](v *T) T { + if v != nil { + return *v + } + var zero T + return zero +} + +type FinalizedChangeAnnotationsSupportOptions struct { + GroupsOnLabel bool +} + +func finalizeChangeAnnotationsSupportOptions(v *ChangeAnnotationsSupportOptions) FinalizedChangeAnnotationsSupportOptions { + if v == nil { + return FinalizedChangeAnnotationsSupportOptions{} + } + return FinalizedChangeAnnotationsSupportOptions{ + GroupsOnLabel: derefOr(v.GroupsOnLabel), + } +} + +type FinalizedWorkspaceEditClientCapabilities struct { + DocumentChanges bool + ResourceOperations []ResourceOperationKind + FailureHandling FailureHandlingKind + NormalizesLineEndings bool + ChangeAnnotationSupport FinalizedChangeAnnotationsSupportOptions + MetadataSupport bool + SnippetEditSupport bool +} + +func finalizeWorkspaceEditClientCapabilities(v *WorkspaceEditClientCapabilities) FinalizedWorkspaceEditClientCapabilities { + if v == nil { + return FinalizedWorkspaceEditClientCapabilities{} + } + return FinalizedWorkspaceEditClientCapabilities{ + DocumentChanges: derefOr(v.DocumentChanges), + ResourceOperations: derefOr(v.ResourceOperations), + FailureHandling: derefOr(v.FailureHandling), + NormalizesLineEndings: derefOr(v.NormalizesLineEndings), + ChangeAnnotationSupport: finalizeChangeAnnotationsSupportOptions(v.ChangeAnnotationSupport), + MetadataSupport: derefOr(v.MetadataSupport), + SnippetEditSupport: derefOr(v.SnippetEditSupport), + } +} + +type FinalizedDidChangeConfigurationClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeDidChangeConfigurationClientCapabilities(v *DidChangeConfigurationClientCapabilities) FinalizedDidChangeConfigurationClientCapabilities { + if v == nil { + return FinalizedDidChangeConfigurationClientCapabilities{} + } + return FinalizedDidChangeConfigurationClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedDidChangeWatchedFilesClientCapabilities struct { + DynamicRegistration bool + RelativePatternSupport bool +} + +func finalizeDidChangeWatchedFilesClientCapabilities(v *DidChangeWatchedFilesClientCapabilities) FinalizedDidChangeWatchedFilesClientCapabilities { + if v == nil { + return FinalizedDidChangeWatchedFilesClientCapabilities{} + } + return FinalizedDidChangeWatchedFilesClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + RelativePatternSupport: derefOr(v.RelativePatternSupport), + } +} + +type FinalizedClientSymbolKindOptions struct { + ValueSet []SymbolKind +} + +func finalizeClientSymbolKindOptions(v *ClientSymbolKindOptions) FinalizedClientSymbolKindOptions { + if v == nil { + return FinalizedClientSymbolKindOptions{} + } + return FinalizedClientSymbolKindOptions{ + ValueSet: derefOr(v.ValueSet), + } +} + +type FinalizedClientSymbolTagOptions struct { + ValueSet []SymbolTag +} + +func finalizeClientSymbolTagOptions(v *ClientSymbolTagOptions) FinalizedClientSymbolTagOptions { + if v == nil { + return FinalizedClientSymbolTagOptions{} + } + return FinalizedClientSymbolTagOptions{ + ValueSet: v.ValueSet, + } +} + +type FinalizedClientSymbolResolveOptions struct { + Properties []string +} + +func finalizeClientSymbolResolveOptions(v *ClientSymbolResolveOptions) FinalizedClientSymbolResolveOptions { + if v == nil { + return FinalizedClientSymbolResolveOptions{} + } + return FinalizedClientSymbolResolveOptions{ + Properties: v.Properties, + } +} + +type FinalizedWorkspaceSymbolClientCapabilities struct { + DynamicRegistration bool + SymbolKind FinalizedClientSymbolKindOptions + TagSupport FinalizedClientSymbolTagOptions + ResolveSupport FinalizedClientSymbolResolveOptions +} + +func finalizeWorkspaceSymbolClientCapabilities(v *WorkspaceSymbolClientCapabilities) FinalizedWorkspaceSymbolClientCapabilities { + if v == nil { + return FinalizedWorkspaceSymbolClientCapabilities{} + } + return FinalizedWorkspaceSymbolClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + SymbolKind: finalizeClientSymbolKindOptions(v.SymbolKind), + TagSupport: finalizeClientSymbolTagOptions(v.TagSupport), + ResolveSupport: finalizeClientSymbolResolveOptions(v.ResolveSupport), + } +} + +type FinalizedExecuteCommandClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeExecuteCommandClientCapabilities(v *ExecuteCommandClientCapabilities) FinalizedExecuteCommandClientCapabilities { + if v == nil { + return FinalizedExecuteCommandClientCapabilities{} + } + return FinalizedExecuteCommandClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedSemanticTokensWorkspaceClientCapabilities struct { + RefreshSupport bool +} + +func finalizeSemanticTokensWorkspaceClientCapabilities(v *SemanticTokensWorkspaceClientCapabilities) FinalizedSemanticTokensWorkspaceClientCapabilities { + if v == nil { + return FinalizedSemanticTokensWorkspaceClientCapabilities{} + } + return FinalizedSemanticTokensWorkspaceClientCapabilities{ + RefreshSupport: derefOr(v.RefreshSupport), + } +} + +type FinalizedCodeLensWorkspaceClientCapabilities struct { + RefreshSupport bool +} + +func finalizeCodeLensWorkspaceClientCapabilities(v *CodeLensWorkspaceClientCapabilities) FinalizedCodeLensWorkspaceClientCapabilities { + if v == nil { + return FinalizedCodeLensWorkspaceClientCapabilities{} + } + return FinalizedCodeLensWorkspaceClientCapabilities{ + RefreshSupport: derefOr(v.RefreshSupport), + } +} + +type FinalizedFileOperationClientCapabilities struct { + DynamicRegistration bool + DidCreate bool + WillCreate bool + DidRename bool + WillRename bool + DidDelete bool + WillDelete bool +} + +func finalizeFileOperationClientCapabilities(v *FileOperationClientCapabilities) FinalizedFileOperationClientCapabilities { + if v == nil { + return FinalizedFileOperationClientCapabilities{} + } + return FinalizedFileOperationClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + DidCreate: derefOr(v.DidCreate), + WillCreate: derefOr(v.WillCreate), + DidRename: derefOr(v.DidRename), + WillRename: derefOr(v.WillRename), + DidDelete: derefOr(v.DidDelete), + WillDelete: derefOr(v.WillDelete), + } +} + +type FinalizedInlineValueWorkspaceClientCapabilities struct { + RefreshSupport bool +} + +func finalizeInlineValueWorkspaceClientCapabilities(v *InlineValueWorkspaceClientCapabilities) FinalizedInlineValueWorkspaceClientCapabilities { + if v == nil { + return FinalizedInlineValueWorkspaceClientCapabilities{} + } + return FinalizedInlineValueWorkspaceClientCapabilities{ + RefreshSupport: derefOr(v.RefreshSupport), + } +} + +type FinalizedInlayHintWorkspaceClientCapabilities struct { + RefreshSupport bool +} + +func finalizeInlayHintWorkspaceClientCapabilities(v *InlayHintWorkspaceClientCapabilities) FinalizedInlayHintWorkspaceClientCapabilities { + if v == nil { + return FinalizedInlayHintWorkspaceClientCapabilities{} + } + return FinalizedInlayHintWorkspaceClientCapabilities{ + RefreshSupport: derefOr(v.RefreshSupport), + } +} + +type FinalizedDiagnosticWorkspaceClientCapabilities struct { + RefreshSupport bool +} + +func finalizeDiagnosticWorkspaceClientCapabilities(v *DiagnosticWorkspaceClientCapabilities) FinalizedDiagnosticWorkspaceClientCapabilities { + if v == nil { + return FinalizedDiagnosticWorkspaceClientCapabilities{} + } + return FinalizedDiagnosticWorkspaceClientCapabilities{ + RefreshSupport: derefOr(v.RefreshSupport), + } +} + +type FinalizedFoldingRangeWorkspaceClientCapabilities struct { + RefreshSupport bool +} + +func finalizeFoldingRangeWorkspaceClientCapabilities(v *FoldingRangeWorkspaceClientCapabilities) FinalizedFoldingRangeWorkspaceClientCapabilities { + if v == nil { + return FinalizedFoldingRangeWorkspaceClientCapabilities{} + } + return FinalizedFoldingRangeWorkspaceClientCapabilities{ + RefreshSupport: derefOr(v.RefreshSupport), + } +} + +type FinalizedTextDocumentContentClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeTextDocumentContentClientCapabilities(v *TextDocumentContentClientCapabilities) FinalizedTextDocumentContentClientCapabilities { + if v == nil { + return FinalizedTextDocumentContentClientCapabilities{} + } + return FinalizedTextDocumentContentClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedWorkspaceClientCapabilities struct { + ApplyEdit bool + WorkspaceEdit FinalizedWorkspaceEditClientCapabilities + DidChangeConfiguration FinalizedDidChangeConfigurationClientCapabilities + DidChangeWatchedFiles FinalizedDidChangeWatchedFilesClientCapabilities + Symbol FinalizedWorkspaceSymbolClientCapabilities + ExecuteCommand FinalizedExecuteCommandClientCapabilities + WorkspaceFolders bool + Configuration bool + SemanticTokens FinalizedSemanticTokensWorkspaceClientCapabilities + CodeLens FinalizedCodeLensWorkspaceClientCapabilities + FileOperations FinalizedFileOperationClientCapabilities + InlineValue FinalizedInlineValueWorkspaceClientCapabilities + InlayHint FinalizedInlayHintWorkspaceClientCapabilities + Diagnostics FinalizedDiagnosticWorkspaceClientCapabilities + FoldingRange FinalizedFoldingRangeWorkspaceClientCapabilities + TextDocumentContent FinalizedTextDocumentContentClientCapabilities +} + +func finalizeWorkspaceClientCapabilities(v *WorkspaceClientCapabilities) FinalizedWorkspaceClientCapabilities { + if v == nil { + return FinalizedWorkspaceClientCapabilities{} + } + return FinalizedWorkspaceClientCapabilities{ + ApplyEdit: derefOr(v.ApplyEdit), + WorkspaceEdit: finalizeWorkspaceEditClientCapabilities(v.WorkspaceEdit), + DidChangeConfiguration: finalizeDidChangeConfigurationClientCapabilities(v.DidChangeConfiguration), + DidChangeWatchedFiles: finalizeDidChangeWatchedFilesClientCapabilities(v.DidChangeWatchedFiles), + Symbol: finalizeWorkspaceSymbolClientCapabilities(v.Symbol), + ExecuteCommand: finalizeExecuteCommandClientCapabilities(v.ExecuteCommand), + WorkspaceFolders: derefOr(v.WorkspaceFolders), + Configuration: derefOr(v.Configuration), + SemanticTokens: finalizeSemanticTokensWorkspaceClientCapabilities(v.SemanticTokens), + CodeLens: finalizeCodeLensWorkspaceClientCapabilities(v.CodeLens), + FileOperations: finalizeFileOperationClientCapabilities(v.FileOperations), + InlineValue: finalizeInlineValueWorkspaceClientCapabilities(v.InlineValue), + InlayHint: finalizeInlayHintWorkspaceClientCapabilities(v.InlayHint), + Diagnostics: finalizeDiagnosticWorkspaceClientCapabilities(v.Diagnostics), + FoldingRange: finalizeFoldingRangeWorkspaceClientCapabilities(v.FoldingRange), + TextDocumentContent: finalizeTextDocumentContentClientCapabilities(v.TextDocumentContent), + } +} + +type FinalizedTextDocumentSyncClientCapabilities struct { + DynamicRegistration bool + WillSave bool + WillSaveWaitUntil bool + DidSave bool +} + +func finalizeTextDocumentSyncClientCapabilities(v *TextDocumentSyncClientCapabilities) FinalizedTextDocumentSyncClientCapabilities { + if v == nil { + return FinalizedTextDocumentSyncClientCapabilities{} + } + return FinalizedTextDocumentSyncClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + WillSave: derefOr(v.WillSave), + WillSaveWaitUntil: derefOr(v.WillSaveWaitUntil), + DidSave: derefOr(v.DidSave), + } +} + +type FinalizedTextDocumentFilterClientCapabilities struct { + RelativePatternSupport bool +} + +func finalizeTextDocumentFilterClientCapabilities(v *TextDocumentFilterClientCapabilities) FinalizedTextDocumentFilterClientCapabilities { + if v == nil { + return FinalizedTextDocumentFilterClientCapabilities{} + } + return FinalizedTextDocumentFilterClientCapabilities{ + RelativePatternSupport: derefOr(v.RelativePatternSupport), + } +} + +type FinalizedCompletionItemTagOptions struct { + ValueSet []CompletionItemTag +} + +func finalizeCompletionItemTagOptions(v *CompletionItemTagOptions) FinalizedCompletionItemTagOptions { + if v == nil { + return FinalizedCompletionItemTagOptions{} + } + return FinalizedCompletionItemTagOptions{ + ValueSet: v.ValueSet, + } +} + +type FinalizedClientCompletionItemResolveOptions struct { + Properties []string +} + +func finalizeClientCompletionItemResolveOptions(v *ClientCompletionItemResolveOptions) FinalizedClientCompletionItemResolveOptions { + if v == nil { + return FinalizedClientCompletionItemResolveOptions{} + } + return FinalizedClientCompletionItemResolveOptions{ + Properties: v.Properties, + } +} + +type FinalizedClientCompletionItemInsertTextModeOptions struct { + ValueSet []InsertTextMode +} + +func finalizeClientCompletionItemInsertTextModeOptions(v *ClientCompletionItemInsertTextModeOptions) FinalizedClientCompletionItemInsertTextModeOptions { + if v == nil { + return FinalizedClientCompletionItemInsertTextModeOptions{} + } + return FinalizedClientCompletionItemInsertTextModeOptions{ + ValueSet: v.ValueSet, + } +} + +type FinalizedClientCompletionItemOptions struct { + SnippetSupport bool + CommitCharactersSupport bool + DocumentationFormat []MarkupKind + DeprecatedSupport bool + PreselectSupport bool + TagSupport FinalizedCompletionItemTagOptions + InsertReplaceSupport bool + ResolveSupport FinalizedClientCompletionItemResolveOptions + InsertTextModeSupport FinalizedClientCompletionItemInsertTextModeOptions + LabelDetailsSupport bool +} + +func finalizeClientCompletionItemOptions(v *ClientCompletionItemOptions) FinalizedClientCompletionItemOptions { + if v == nil { + return FinalizedClientCompletionItemOptions{} + } + return FinalizedClientCompletionItemOptions{ + SnippetSupport: derefOr(v.SnippetSupport), + CommitCharactersSupport: derefOr(v.CommitCharactersSupport), + DocumentationFormat: derefOr(v.DocumentationFormat), + DeprecatedSupport: derefOr(v.DeprecatedSupport), + PreselectSupport: derefOr(v.PreselectSupport), + TagSupport: finalizeCompletionItemTagOptions(v.TagSupport), + InsertReplaceSupport: derefOr(v.InsertReplaceSupport), + ResolveSupport: finalizeClientCompletionItemResolveOptions(v.ResolveSupport), + InsertTextModeSupport: finalizeClientCompletionItemInsertTextModeOptions(v.InsertTextModeSupport), + LabelDetailsSupport: derefOr(v.LabelDetailsSupport), + } +} + +type FinalizedClientCompletionItemOptionsKind struct { + ValueSet []CompletionItemKind +} + +func finalizeClientCompletionItemOptionsKind(v *ClientCompletionItemOptionsKind) FinalizedClientCompletionItemOptionsKind { + if v == nil { + return FinalizedClientCompletionItemOptionsKind{} + } + return FinalizedClientCompletionItemOptionsKind{ + ValueSet: derefOr(v.ValueSet), + } +} + +type FinalizedCompletionListCapabilities struct { + ItemDefaults []string + ApplyKindSupport bool +} + +func finalizeCompletionListCapabilities(v *CompletionListCapabilities) FinalizedCompletionListCapabilities { + if v == nil { + return FinalizedCompletionListCapabilities{} + } + return FinalizedCompletionListCapabilities{ + ItemDefaults: derefOr(v.ItemDefaults), + ApplyKindSupport: derefOr(v.ApplyKindSupport), + } +} + +type FinalizedCompletionClientCapabilities struct { + DynamicRegistration bool + CompletionItem FinalizedClientCompletionItemOptions + CompletionItemKind FinalizedClientCompletionItemOptionsKind + InsertTextMode InsertTextMode + ContextSupport bool + CompletionList FinalizedCompletionListCapabilities +} + +func finalizeCompletionClientCapabilities(v *CompletionClientCapabilities) FinalizedCompletionClientCapabilities { + if v == nil { + return FinalizedCompletionClientCapabilities{} + } + return FinalizedCompletionClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + CompletionItem: finalizeClientCompletionItemOptions(v.CompletionItem), + CompletionItemKind: finalizeClientCompletionItemOptionsKind(v.CompletionItemKind), + InsertTextMode: derefOr(v.InsertTextMode), + ContextSupport: derefOr(v.ContextSupport), + CompletionList: finalizeCompletionListCapabilities(v.CompletionList), + } +} + +type FinalizedHoverClientCapabilities struct { + DynamicRegistration bool + ContentFormat []MarkupKind +} + +func finalizeHoverClientCapabilities(v *HoverClientCapabilities) FinalizedHoverClientCapabilities { + if v == nil { + return FinalizedHoverClientCapabilities{} + } + return FinalizedHoverClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + ContentFormat: derefOr(v.ContentFormat), + } +} + +type FinalizedClientSignatureParameterInformationOptions struct { + LabelOffsetSupport bool +} + +func finalizeClientSignatureParameterInformationOptions(v *ClientSignatureParameterInformationOptions) FinalizedClientSignatureParameterInformationOptions { + if v == nil { + return FinalizedClientSignatureParameterInformationOptions{} + } + return FinalizedClientSignatureParameterInformationOptions{ + LabelOffsetSupport: derefOr(v.LabelOffsetSupport), + } +} + +type FinalizedClientSignatureInformationOptions struct { + DocumentationFormat []MarkupKind + ParameterInformation FinalizedClientSignatureParameterInformationOptions + ActiveParameterSupport bool + NoActiveParameterSupport bool +} + +func finalizeClientSignatureInformationOptions(v *ClientSignatureInformationOptions) FinalizedClientSignatureInformationOptions { + if v == nil { + return FinalizedClientSignatureInformationOptions{} + } + return FinalizedClientSignatureInformationOptions{ + DocumentationFormat: derefOr(v.DocumentationFormat), + ParameterInformation: finalizeClientSignatureParameterInformationOptions(v.ParameterInformation), + ActiveParameterSupport: derefOr(v.ActiveParameterSupport), + NoActiveParameterSupport: derefOr(v.NoActiveParameterSupport), + } +} + +type FinalizedSignatureHelpClientCapabilities struct { + DynamicRegistration bool + SignatureInformation FinalizedClientSignatureInformationOptions + ContextSupport bool +} + +func finalizeSignatureHelpClientCapabilities(v *SignatureHelpClientCapabilities) FinalizedSignatureHelpClientCapabilities { + if v == nil { + return FinalizedSignatureHelpClientCapabilities{} + } + return FinalizedSignatureHelpClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + SignatureInformation: finalizeClientSignatureInformationOptions(v.SignatureInformation), + ContextSupport: derefOr(v.ContextSupport), + } +} + +type FinalizedDeclarationClientCapabilities struct { + DynamicRegistration bool + LinkSupport bool +} + +func finalizeDeclarationClientCapabilities(v *DeclarationClientCapabilities) FinalizedDeclarationClientCapabilities { + if v == nil { + return FinalizedDeclarationClientCapabilities{} + } + return FinalizedDeclarationClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + LinkSupport: derefOr(v.LinkSupport), + } +} + +type FinalizedDefinitionClientCapabilities struct { + DynamicRegistration bool + LinkSupport bool +} + +func finalizeDefinitionClientCapabilities(v *DefinitionClientCapabilities) FinalizedDefinitionClientCapabilities { + if v == nil { + return FinalizedDefinitionClientCapabilities{} + } + return FinalizedDefinitionClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + LinkSupport: derefOr(v.LinkSupport), + } +} + +type FinalizedTypeDefinitionClientCapabilities struct { + DynamicRegistration bool + LinkSupport bool +} + +func finalizeTypeDefinitionClientCapabilities(v *TypeDefinitionClientCapabilities) FinalizedTypeDefinitionClientCapabilities { + if v == nil { + return FinalizedTypeDefinitionClientCapabilities{} + } + return FinalizedTypeDefinitionClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + LinkSupport: derefOr(v.LinkSupport), + } +} + +type FinalizedImplementationClientCapabilities struct { + DynamicRegistration bool + LinkSupport bool +} + +func finalizeImplementationClientCapabilities(v *ImplementationClientCapabilities) FinalizedImplementationClientCapabilities { + if v == nil { + return FinalizedImplementationClientCapabilities{} + } + return FinalizedImplementationClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + LinkSupport: derefOr(v.LinkSupport), + } +} + +type FinalizedReferenceClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeReferenceClientCapabilities(v *ReferenceClientCapabilities) FinalizedReferenceClientCapabilities { + if v == nil { + return FinalizedReferenceClientCapabilities{} + } + return FinalizedReferenceClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedDocumentHighlightClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeDocumentHighlightClientCapabilities(v *DocumentHighlightClientCapabilities) FinalizedDocumentHighlightClientCapabilities { + if v == nil { + return FinalizedDocumentHighlightClientCapabilities{} + } + return FinalizedDocumentHighlightClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedDocumentSymbolClientCapabilities struct { + DynamicRegistration bool + SymbolKind FinalizedClientSymbolKindOptions + HierarchicalDocumentSymbolSupport bool + TagSupport FinalizedClientSymbolTagOptions + LabelSupport bool +} + +func finalizeDocumentSymbolClientCapabilities(v *DocumentSymbolClientCapabilities) FinalizedDocumentSymbolClientCapabilities { + if v == nil { + return FinalizedDocumentSymbolClientCapabilities{} + } + return FinalizedDocumentSymbolClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + SymbolKind: finalizeClientSymbolKindOptions(v.SymbolKind), + HierarchicalDocumentSymbolSupport: derefOr(v.HierarchicalDocumentSymbolSupport), + TagSupport: finalizeClientSymbolTagOptions(v.TagSupport), + LabelSupport: derefOr(v.LabelSupport), + } +} + +type FinalizedClientCodeActionKindOptions struct { + ValueSet []CodeActionKind +} + +func finalizeClientCodeActionKindOptions(v *ClientCodeActionKindOptions) FinalizedClientCodeActionKindOptions { + if v == nil { + return FinalizedClientCodeActionKindOptions{} + } + return FinalizedClientCodeActionKindOptions{ + ValueSet: v.ValueSet, + } +} + +type FinalizedClientCodeActionLiteralOptions struct { + CodeActionKind FinalizedClientCodeActionKindOptions +} + +func finalizeClientCodeActionLiteralOptions(v *ClientCodeActionLiteralOptions) FinalizedClientCodeActionLiteralOptions { + if v == nil { + return FinalizedClientCodeActionLiteralOptions{} + } + return FinalizedClientCodeActionLiteralOptions{ + CodeActionKind: finalizeClientCodeActionKindOptions(v.CodeActionKind), + } +} + +type FinalizedClientCodeActionResolveOptions struct { + Properties []string +} + +func finalizeClientCodeActionResolveOptions(v *ClientCodeActionResolveOptions) FinalizedClientCodeActionResolveOptions { + if v == nil { + return FinalizedClientCodeActionResolveOptions{} + } + return FinalizedClientCodeActionResolveOptions{ + Properties: v.Properties, + } +} + +type FinalizedCodeActionTagOptions struct { + ValueSet []CodeActionTag +} + +func finalizeCodeActionTagOptions(v *CodeActionTagOptions) FinalizedCodeActionTagOptions { + if v == nil { + return FinalizedCodeActionTagOptions{} + } + return FinalizedCodeActionTagOptions{ + ValueSet: v.ValueSet, + } +} + +type FinalizedCodeActionClientCapabilities struct { + DynamicRegistration bool + CodeActionLiteralSupport FinalizedClientCodeActionLiteralOptions + IsPreferredSupport bool + DisabledSupport bool + DataSupport bool + ResolveSupport FinalizedClientCodeActionResolveOptions + HonorsChangeAnnotations bool + DocumentationSupport bool + TagSupport FinalizedCodeActionTagOptions +} + +func finalizeCodeActionClientCapabilities(v *CodeActionClientCapabilities) FinalizedCodeActionClientCapabilities { + if v == nil { + return FinalizedCodeActionClientCapabilities{} + } + return FinalizedCodeActionClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + CodeActionLiteralSupport: finalizeClientCodeActionLiteralOptions(v.CodeActionLiteralSupport), + IsPreferredSupport: derefOr(v.IsPreferredSupport), + DisabledSupport: derefOr(v.DisabledSupport), + DataSupport: derefOr(v.DataSupport), + ResolveSupport: finalizeClientCodeActionResolveOptions(v.ResolveSupport), + HonorsChangeAnnotations: derefOr(v.HonorsChangeAnnotations), + DocumentationSupport: derefOr(v.DocumentationSupport), + TagSupport: finalizeCodeActionTagOptions(v.TagSupport), + } +} + +type FinalizedClientCodeLensResolveOptions struct { + Properties []string +} + +func finalizeClientCodeLensResolveOptions(v *ClientCodeLensResolveOptions) FinalizedClientCodeLensResolveOptions { + if v == nil { + return FinalizedClientCodeLensResolveOptions{} + } + return FinalizedClientCodeLensResolveOptions{ + Properties: v.Properties, + } +} + +type FinalizedCodeLensClientCapabilities struct { + DynamicRegistration bool + ResolveSupport FinalizedClientCodeLensResolveOptions +} + +func finalizeCodeLensClientCapabilities(v *CodeLensClientCapabilities) FinalizedCodeLensClientCapabilities { + if v == nil { + return FinalizedCodeLensClientCapabilities{} + } + return FinalizedCodeLensClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + ResolveSupport: finalizeClientCodeLensResolveOptions(v.ResolveSupport), + } +} + +type FinalizedDocumentLinkClientCapabilities struct { + DynamicRegistration bool + TooltipSupport bool +} + +func finalizeDocumentLinkClientCapabilities(v *DocumentLinkClientCapabilities) FinalizedDocumentLinkClientCapabilities { + if v == nil { + return FinalizedDocumentLinkClientCapabilities{} + } + return FinalizedDocumentLinkClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + TooltipSupport: derefOr(v.TooltipSupport), + } +} + +type FinalizedDocumentColorClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeDocumentColorClientCapabilities(v *DocumentColorClientCapabilities) FinalizedDocumentColorClientCapabilities { + if v == nil { + return FinalizedDocumentColorClientCapabilities{} + } + return FinalizedDocumentColorClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedDocumentFormattingClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeDocumentFormattingClientCapabilities(v *DocumentFormattingClientCapabilities) FinalizedDocumentFormattingClientCapabilities { + if v == nil { + return FinalizedDocumentFormattingClientCapabilities{} + } + return FinalizedDocumentFormattingClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedDocumentRangeFormattingClientCapabilities struct { + DynamicRegistration bool + RangesSupport bool +} + +func finalizeDocumentRangeFormattingClientCapabilities(v *DocumentRangeFormattingClientCapabilities) FinalizedDocumentRangeFormattingClientCapabilities { + if v == nil { + return FinalizedDocumentRangeFormattingClientCapabilities{} + } + return FinalizedDocumentRangeFormattingClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + RangesSupport: derefOr(v.RangesSupport), + } +} + +type FinalizedDocumentOnTypeFormattingClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeDocumentOnTypeFormattingClientCapabilities(v *DocumentOnTypeFormattingClientCapabilities) FinalizedDocumentOnTypeFormattingClientCapabilities { + if v == nil { + return FinalizedDocumentOnTypeFormattingClientCapabilities{} + } + return FinalizedDocumentOnTypeFormattingClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedRenameClientCapabilities struct { + DynamicRegistration bool + PrepareSupport bool + PrepareSupportDefaultBehavior PrepareSupportDefaultBehavior + HonorsChangeAnnotations bool +} + +func finalizeRenameClientCapabilities(v *RenameClientCapabilities) FinalizedRenameClientCapabilities { + if v == nil { + return FinalizedRenameClientCapabilities{} + } + return FinalizedRenameClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + PrepareSupport: derefOr(v.PrepareSupport), + PrepareSupportDefaultBehavior: derefOr(v.PrepareSupportDefaultBehavior), + HonorsChangeAnnotations: derefOr(v.HonorsChangeAnnotations), + } +} + +type FinalizedClientFoldingRangeKindOptions struct { + ValueSet []FoldingRangeKind +} + +func finalizeClientFoldingRangeKindOptions(v *ClientFoldingRangeKindOptions) FinalizedClientFoldingRangeKindOptions { + if v == nil { + return FinalizedClientFoldingRangeKindOptions{} + } + return FinalizedClientFoldingRangeKindOptions{ + ValueSet: derefOr(v.ValueSet), + } +} + +type FinalizedClientFoldingRangeOptions struct { + CollapsedText bool +} + +func finalizeClientFoldingRangeOptions(v *ClientFoldingRangeOptions) FinalizedClientFoldingRangeOptions { + if v == nil { + return FinalizedClientFoldingRangeOptions{} + } + return FinalizedClientFoldingRangeOptions{ + CollapsedText: derefOr(v.CollapsedText), + } +} + +type FinalizedFoldingRangeClientCapabilities struct { + DynamicRegistration bool + RangeLimit uint32 + LineFoldingOnly bool + FoldingRangeKind FinalizedClientFoldingRangeKindOptions + FoldingRange FinalizedClientFoldingRangeOptions +} + +func finalizeFoldingRangeClientCapabilities(v *FoldingRangeClientCapabilities) FinalizedFoldingRangeClientCapabilities { + if v == nil { + return FinalizedFoldingRangeClientCapabilities{} + } + return FinalizedFoldingRangeClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + RangeLimit: derefOr(v.RangeLimit), + LineFoldingOnly: derefOr(v.LineFoldingOnly), + FoldingRangeKind: finalizeClientFoldingRangeKindOptions(v.FoldingRangeKind), + FoldingRange: finalizeClientFoldingRangeOptions(v.FoldingRange), + } +} + +type FinalizedSelectionRangeClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeSelectionRangeClientCapabilities(v *SelectionRangeClientCapabilities) FinalizedSelectionRangeClientCapabilities { + if v == nil { + return FinalizedSelectionRangeClientCapabilities{} + } + return FinalizedSelectionRangeClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedClientDiagnosticsTagOptions struct { + ValueSet []DiagnosticTag +} + +func finalizeClientDiagnosticsTagOptions(v *ClientDiagnosticsTagOptions) FinalizedClientDiagnosticsTagOptions { + if v == nil { + return FinalizedClientDiagnosticsTagOptions{} + } + return FinalizedClientDiagnosticsTagOptions{ + ValueSet: v.ValueSet, + } +} + +type FinalizedPublishDiagnosticsClientCapabilities struct { + RelatedInformation bool + TagSupport FinalizedClientDiagnosticsTagOptions + CodeDescriptionSupport bool + DataSupport bool + VersionSupport bool +} + +func finalizePublishDiagnosticsClientCapabilities(v *PublishDiagnosticsClientCapabilities) FinalizedPublishDiagnosticsClientCapabilities { + if v == nil { + return FinalizedPublishDiagnosticsClientCapabilities{} + } + return FinalizedPublishDiagnosticsClientCapabilities{ + RelatedInformation: derefOr(v.RelatedInformation), + TagSupport: finalizeClientDiagnosticsTagOptions(v.TagSupport), + CodeDescriptionSupport: derefOr(v.CodeDescriptionSupport), + DataSupport: derefOr(v.DataSupport), + VersionSupport: derefOr(v.VersionSupport), + } +} + +type FinalizedCallHierarchyClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeCallHierarchyClientCapabilities(v *CallHierarchyClientCapabilities) FinalizedCallHierarchyClientCapabilities { + if v == nil { + return FinalizedCallHierarchyClientCapabilities{} + } + return FinalizedCallHierarchyClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedClientSemanticTokensRequestOptions struct { + Range BooleanOrEmptyObject + Full BooleanOrClientSemanticTokensRequestFullDelta +} + +func finalizeClientSemanticTokensRequestOptions(v *ClientSemanticTokensRequestOptions) FinalizedClientSemanticTokensRequestOptions { + if v == nil { + return FinalizedClientSemanticTokensRequestOptions{} + } + return FinalizedClientSemanticTokensRequestOptions{ + Range: derefOr(v.Range), + Full: derefOr(v.Full), + } +} + +type FinalizedSemanticTokensClientCapabilities struct { + DynamicRegistration bool + Requests FinalizedClientSemanticTokensRequestOptions + TokenTypes []string + TokenModifiers []string + Formats []TokenFormat + OverlappingTokenSupport bool + MultilineTokenSupport bool + ServerCancelSupport bool + AugmentsSyntaxTokens bool +} + +func finalizeSemanticTokensClientCapabilities(v *SemanticTokensClientCapabilities) FinalizedSemanticTokensClientCapabilities { + if v == nil { + return FinalizedSemanticTokensClientCapabilities{} + } + return FinalizedSemanticTokensClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + Requests: finalizeClientSemanticTokensRequestOptions(v.Requests), + TokenTypes: v.TokenTypes, + TokenModifiers: v.TokenModifiers, + Formats: v.Formats, + OverlappingTokenSupport: derefOr(v.OverlappingTokenSupport), + MultilineTokenSupport: derefOr(v.MultilineTokenSupport), + ServerCancelSupport: derefOr(v.ServerCancelSupport), + AugmentsSyntaxTokens: derefOr(v.AugmentsSyntaxTokens), + } +} + +type FinalizedLinkedEditingRangeClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeLinkedEditingRangeClientCapabilities(v *LinkedEditingRangeClientCapabilities) FinalizedLinkedEditingRangeClientCapabilities { + if v == nil { + return FinalizedLinkedEditingRangeClientCapabilities{} + } + return FinalizedLinkedEditingRangeClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedMonikerClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeMonikerClientCapabilities(v *MonikerClientCapabilities) FinalizedMonikerClientCapabilities { + if v == nil { + return FinalizedMonikerClientCapabilities{} + } + return FinalizedMonikerClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedTypeHierarchyClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeTypeHierarchyClientCapabilities(v *TypeHierarchyClientCapabilities) FinalizedTypeHierarchyClientCapabilities { + if v == nil { + return FinalizedTypeHierarchyClientCapabilities{} + } + return FinalizedTypeHierarchyClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedInlineValueClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeInlineValueClientCapabilities(v *InlineValueClientCapabilities) FinalizedInlineValueClientCapabilities { + if v == nil { + return FinalizedInlineValueClientCapabilities{} + } + return FinalizedInlineValueClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedClientInlayHintResolveOptions struct { + Properties []string +} + +func finalizeClientInlayHintResolveOptions(v *ClientInlayHintResolveOptions) FinalizedClientInlayHintResolveOptions { + if v == nil { + return FinalizedClientInlayHintResolveOptions{} + } + return FinalizedClientInlayHintResolveOptions{ + Properties: v.Properties, + } +} + +type FinalizedInlayHintClientCapabilities struct { + DynamicRegistration bool + ResolveSupport FinalizedClientInlayHintResolveOptions +} + +func finalizeInlayHintClientCapabilities(v *InlayHintClientCapabilities) FinalizedInlayHintClientCapabilities { + if v == nil { + return FinalizedInlayHintClientCapabilities{} + } + return FinalizedInlayHintClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + ResolveSupport: finalizeClientInlayHintResolveOptions(v.ResolveSupport), + } +} + +type FinalizedDiagnosticClientCapabilities struct { + RelatedInformation bool + TagSupport FinalizedClientDiagnosticsTagOptions + CodeDescriptionSupport bool + DataSupport bool + DynamicRegistration bool + RelatedDocumentSupport bool +} + +func finalizeDiagnosticClientCapabilities(v *DiagnosticClientCapabilities) FinalizedDiagnosticClientCapabilities { + if v == nil { + return FinalizedDiagnosticClientCapabilities{} + } + return FinalizedDiagnosticClientCapabilities{ + RelatedInformation: derefOr(v.RelatedInformation), + TagSupport: finalizeClientDiagnosticsTagOptions(v.TagSupport), + CodeDescriptionSupport: derefOr(v.CodeDescriptionSupport), + DataSupport: derefOr(v.DataSupport), + DynamicRegistration: derefOr(v.DynamicRegistration), + RelatedDocumentSupport: derefOr(v.RelatedDocumentSupport), + } +} + +type FinalizedInlineCompletionClientCapabilities struct { + DynamicRegistration bool +} + +func finalizeInlineCompletionClientCapabilities(v *InlineCompletionClientCapabilities) FinalizedInlineCompletionClientCapabilities { + if v == nil { + return FinalizedInlineCompletionClientCapabilities{} + } + return FinalizedInlineCompletionClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + } +} + +type FinalizedTextDocumentClientCapabilities struct { + Synchronization FinalizedTextDocumentSyncClientCapabilities + Filters FinalizedTextDocumentFilterClientCapabilities + Completion FinalizedCompletionClientCapabilities + Hover FinalizedHoverClientCapabilities + SignatureHelp FinalizedSignatureHelpClientCapabilities + Declaration FinalizedDeclarationClientCapabilities + Definition FinalizedDefinitionClientCapabilities + TypeDefinition FinalizedTypeDefinitionClientCapabilities + Implementation FinalizedImplementationClientCapabilities + References FinalizedReferenceClientCapabilities + DocumentHighlight FinalizedDocumentHighlightClientCapabilities + DocumentSymbol FinalizedDocumentSymbolClientCapabilities + CodeAction FinalizedCodeActionClientCapabilities + CodeLens FinalizedCodeLensClientCapabilities + DocumentLink FinalizedDocumentLinkClientCapabilities + ColorProvider FinalizedDocumentColorClientCapabilities + Formatting FinalizedDocumentFormattingClientCapabilities + RangeFormatting FinalizedDocumentRangeFormattingClientCapabilities + OnTypeFormatting FinalizedDocumentOnTypeFormattingClientCapabilities + Rename FinalizedRenameClientCapabilities + FoldingRange FinalizedFoldingRangeClientCapabilities + SelectionRange FinalizedSelectionRangeClientCapabilities + PublishDiagnostics FinalizedPublishDiagnosticsClientCapabilities + CallHierarchy FinalizedCallHierarchyClientCapabilities + SemanticTokens FinalizedSemanticTokensClientCapabilities + LinkedEditingRange FinalizedLinkedEditingRangeClientCapabilities + Moniker FinalizedMonikerClientCapabilities + TypeHierarchy FinalizedTypeHierarchyClientCapabilities + InlineValue FinalizedInlineValueClientCapabilities + InlayHint FinalizedInlayHintClientCapabilities + Diagnostic FinalizedDiagnosticClientCapabilities + InlineCompletion FinalizedInlineCompletionClientCapabilities +} + +func finalizeTextDocumentClientCapabilities(v *TextDocumentClientCapabilities) FinalizedTextDocumentClientCapabilities { + if v == nil { + return FinalizedTextDocumentClientCapabilities{} + } + return FinalizedTextDocumentClientCapabilities{ + Synchronization: finalizeTextDocumentSyncClientCapabilities(v.Synchronization), + Filters: finalizeTextDocumentFilterClientCapabilities(v.Filters), + Completion: finalizeCompletionClientCapabilities(v.Completion), + Hover: finalizeHoverClientCapabilities(v.Hover), + SignatureHelp: finalizeSignatureHelpClientCapabilities(v.SignatureHelp), + Declaration: finalizeDeclarationClientCapabilities(v.Declaration), + Definition: finalizeDefinitionClientCapabilities(v.Definition), + TypeDefinition: finalizeTypeDefinitionClientCapabilities(v.TypeDefinition), + Implementation: finalizeImplementationClientCapabilities(v.Implementation), + References: finalizeReferenceClientCapabilities(v.References), + DocumentHighlight: finalizeDocumentHighlightClientCapabilities(v.DocumentHighlight), + DocumentSymbol: finalizeDocumentSymbolClientCapabilities(v.DocumentSymbol), + CodeAction: finalizeCodeActionClientCapabilities(v.CodeAction), + CodeLens: finalizeCodeLensClientCapabilities(v.CodeLens), + DocumentLink: finalizeDocumentLinkClientCapabilities(v.DocumentLink), + ColorProvider: finalizeDocumentColorClientCapabilities(v.ColorProvider), + Formatting: finalizeDocumentFormattingClientCapabilities(v.Formatting), + RangeFormatting: finalizeDocumentRangeFormattingClientCapabilities(v.RangeFormatting), + OnTypeFormatting: finalizeDocumentOnTypeFormattingClientCapabilities(v.OnTypeFormatting), + Rename: finalizeRenameClientCapabilities(v.Rename), + FoldingRange: finalizeFoldingRangeClientCapabilities(v.FoldingRange), + SelectionRange: finalizeSelectionRangeClientCapabilities(v.SelectionRange), + PublishDiagnostics: finalizePublishDiagnosticsClientCapabilities(v.PublishDiagnostics), + CallHierarchy: finalizeCallHierarchyClientCapabilities(v.CallHierarchy), + SemanticTokens: finalizeSemanticTokensClientCapabilities(v.SemanticTokens), + LinkedEditingRange: finalizeLinkedEditingRangeClientCapabilities(v.LinkedEditingRange), + Moniker: finalizeMonikerClientCapabilities(v.Moniker), + TypeHierarchy: finalizeTypeHierarchyClientCapabilities(v.TypeHierarchy), + InlineValue: finalizeInlineValueClientCapabilities(v.InlineValue), + InlayHint: finalizeInlayHintClientCapabilities(v.InlayHint), + Diagnostic: finalizeDiagnosticClientCapabilities(v.Diagnostic), + InlineCompletion: finalizeInlineCompletionClientCapabilities(v.InlineCompletion), + } +} + +type FinalizedNotebookDocumentSyncClientCapabilities struct { + DynamicRegistration bool + ExecutionSummarySupport bool +} + +func finalizeNotebookDocumentSyncClientCapabilities(v *NotebookDocumentSyncClientCapabilities) FinalizedNotebookDocumentSyncClientCapabilities { + if v == nil { + return FinalizedNotebookDocumentSyncClientCapabilities{} + } + return FinalizedNotebookDocumentSyncClientCapabilities{ + DynamicRegistration: derefOr(v.DynamicRegistration), + ExecutionSummarySupport: derefOr(v.ExecutionSummarySupport), + } +} + +type FinalizedNotebookDocumentClientCapabilities struct { + Synchronization FinalizedNotebookDocumentSyncClientCapabilities +} + +func finalizeNotebookDocumentClientCapabilities(v *NotebookDocumentClientCapabilities) FinalizedNotebookDocumentClientCapabilities { + if v == nil { + return FinalizedNotebookDocumentClientCapabilities{} + } + return FinalizedNotebookDocumentClientCapabilities{ + Synchronization: finalizeNotebookDocumentSyncClientCapabilities(v.Synchronization), + } +} + +type FinalizedClientShowMessageActionItemOptions struct { + AdditionalPropertiesSupport bool +} + +func finalizeClientShowMessageActionItemOptions(v *ClientShowMessageActionItemOptions) FinalizedClientShowMessageActionItemOptions { + if v == nil { + return FinalizedClientShowMessageActionItemOptions{} + } + return FinalizedClientShowMessageActionItemOptions{ + AdditionalPropertiesSupport: derefOr(v.AdditionalPropertiesSupport), + } +} + +type FinalizedShowMessageRequestClientCapabilities struct { + MessageActionItem FinalizedClientShowMessageActionItemOptions +} + +func finalizeShowMessageRequestClientCapabilities(v *ShowMessageRequestClientCapabilities) FinalizedShowMessageRequestClientCapabilities { + if v == nil { + return FinalizedShowMessageRequestClientCapabilities{} + } + return FinalizedShowMessageRequestClientCapabilities{ + MessageActionItem: finalizeClientShowMessageActionItemOptions(v.MessageActionItem), + } +} + +type FinalizedShowDocumentClientCapabilities struct { + Support bool +} + +func finalizeShowDocumentClientCapabilities(v *ShowDocumentClientCapabilities) FinalizedShowDocumentClientCapabilities { + if v == nil { + return FinalizedShowDocumentClientCapabilities{} + } + return FinalizedShowDocumentClientCapabilities{ + Support: v.Support, + } +} + +type FinalizedWindowClientCapabilities struct { + WorkDoneProgress bool + ShowMessage FinalizedShowMessageRequestClientCapabilities + ShowDocument FinalizedShowDocumentClientCapabilities +} + +func finalizeWindowClientCapabilities(v *WindowClientCapabilities) FinalizedWindowClientCapabilities { + if v == nil { + return FinalizedWindowClientCapabilities{} + } + return FinalizedWindowClientCapabilities{ + WorkDoneProgress: derefOr(v.WorkDoneProgress), + ShowMessage: finalizeShowMessageRequestClientCapabilities(v.ShowMessage), + ShowDocument: finalizeShowDocumentClientCapabilities(v.ShowDocument), + } +} + +type FinalizedStaleRequestSupportOptions struct { + Cancel bool + RetryOnContentModified []string +} + +func finalizeStaleRequestSupportOptions(v *StaleRequestSupportOptions) FinalizedStaleRequestSupportOptions { + if v == nil { + return FinalizedStaleRequestSupportOptions{} + } + return FinalizedStaleRequestSupportOptions{ + Cancel: v.Cancel, + RetryOnContentModified: v.RetryOnContentModified, + } +} + +type FinalizedRegularExpressionsClientCapabilities struct { + Engine string + Version string +} + +func finalizeRegularExpressionsClientCapabilities(v *RegularExpressionsClientCapabilities) FinalizedRegularExpressionsClientCapabilities { + if v == nil { + return FinalizedRegularExpressionsClientCapabilities{} + } + return FinalizedRegularExpressionsClientCapabilities{ + Engine: v.Engine, + Version: derefOr(v.Version), + } +} + +type FinalizedMarkdownClientCapabilities struct { + Parser string + Version string + AllowedTags []string +} + +func finalizeMarkdownClientCapabilities(v *MarkdownClientCapabilities) FinalizedMarkdownClientCapabilities { + if v == nil { + return FinalizedMarkdownClientCapabilities{} + } + return FinalizedMarkdownClientCapabilities{ + Parser: v.Parser, + Version: derefOr(v.Version), + AllowedTags: derefOr(v.AllowedTags), + } +} + +type FinalizedGeneralClientCapabilities struct { + StaleRequestSupport FinalizedStaleRequestSupportOptions + RegularExpressions FinalizedRegularExpressionsClientCapabilities + Markdown FinalizedMarkdownClientCapabilities + PositionEncodings []PositionEncodingKind +} + +func finalizeGeneralClientCapabilities(v *GeneralClientCapabilities) FinalizedGeneralClientCapabilities { + if v == nil { + return FinalizedGeneralClientCapabilities{} + } + return FinalizedGeneralClientCapabilities{ + StaleRequestSupport: finalizeStaleRequestSupportOptions(v.StaleRequestSupport), + RegularExpressions: finalizeRegularExpressionsClientCapabilities(v.RegularExpressions), + Markdown: finalizeMarkdownClientCapabilities(v.Markdown), + PositionEncodings: derefOr(v.PositionEncodings), + } +} + +// FinalizedClientCapabilities is a version of ClientCapabilities where all nested +// fields are values (not pointers), making it easier to access deeply nested capabilities. +// Use FinalizeClientCapabilities to convert from ClientCapabilities. +type FinalizedClientCapabilities struct { + Workspace FinalizedWorkspaceClientCapabilities + TextDocument FinalizedTextDocumentClientCapabilities + NotebookDocument FinalizedNotebookDocumentClientCapabilities + Window FinalizedWindowClientCapabilities + General FinalizedGeneralClientCapabilities + Experimental any +} + +func FinalizeClientCapabilities(v *ClientCapabilities) FinalizedClientCapabilities { + if v == nil { + return FinalizedClientCapabilities{} + } + return FinalizedClientCapabilities{ + Workspace: finalizeWorkspaceClientCapabilities(v.Workspace), + TextDocument: finalizeTextDocumentClientCapabilities(v.TextDocument), + NotebookDocument: finalizeNotebookDocumentClientCapabilities(v.NotebookDocument), + Window: finalizeWindowClientCapabilities(v.Window), + General: finalizeGeneralClientCapabilities(v.General), + Experimental: derefOr(v.Experimental), + } +} diff --git a/internal/lsp/server.go b/internal/lsp/server.go index 29037f6c74..eaa1e3b120 100644 --- a/internal/lsp/server.go +++ b/internal/lsp/server.go @@ -690,6 +690,10 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ return response, nil } +func (s *Server) FinalizedClientCapabilities() lsproto.FinalizedClientCapabilities { + return lsproto.FinalizeClientCapabilities(s.initializeParams.Capabilities) +} + func (s *Server) handleInitialized(ctx context.Context, params *lsproto.InitializedParams) error { if shouldEnableWatch(s.initializeParams) { s.watchEnabled = true @@ -831,11 +835,11 @@ func (s *Server) handleSignatureHelp(ctx context.Context, languageService *ls.La } func (s *Server) handleDefinition(ctx context.Context, ls *ls.LanguageService, params *lsproto.DefinitionParams) (lsproto.DefinitionResponse, error) { - return ls.ProvideDefinition(ctx, params.TextDocument.Uri, params.Position, getDefinitionClientSupportsLink(s.initializeParams)) + return ls.ProvideDefinition(ctx, params.TextDocument.Uri, params.Position, getDefinitionClientSupportsLink(s.FinalizedClientCapabilities())) } func (s *Server) handleTypeDefinition(ctx context.Context, ls *ls.LanguageService, params *lsproto.TypeDefinitionParams) (lsproto.TypeDefinitionResponse, error) { - return ls.ProvideTypeDefinition(ctx, params.TextDocument.Uri, params.Position, getTypeDefinitionClientSupportsLink(s.initializeParams)) + return ls.ProvideTypeDefinition(ctx, params.TextDocument.Uri, params.Position, getTypeDefinitionClientSupportsLink(s.FinalizedClientCapabilities())) } func (s *Server) handleReferences(ctx context.Context, ls *ls.LanguageService, params *lsproto.ReferenceParams) (lsproto.ReferencesResponse, error) { @@ -845,7 +849,7 @@ func (s *Server) handleReferences(ctx context.Context, ls *ls.LanguageService, p func (s *Server) handleImplementations(ctx context.Context, ls *ls.LanguageService, params *lsproto.ImplementationParams) (lsproto.ImplementationResponse, error) { // goToImplementation - return ls.ProvideImplementations(ctx, params, getImplementationClientSupportsLink(s.initializeParams)) + return ls.ProvideImplementations(ctx, params, getImplementationClientSupportsLink(s.FinalizedClientCapabilities())) } func (s *Server) handleCompletion(ctx context.Context, languageService *ls.LanguageService, params *lsproto.CompletionParams) (lsproto.CompletionResponse, error) { @@ -998,28 +1002,16 @@ func (s *Server) handleInlayHint( return languageService.ProvideInlayHint(ctx, params) } -func getDefinitionClientSupportsLink(params *lsproto.InitializeParams) bool { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil || - params.Capabilities.TextDocument.Definition == nil { - return false - } - return ptrIsTrue(params.Capabilities.TextDocument.Definition.LinkSupport) +func getDefinitionClientSupportsLink(caps lsproto.FinalizedClientCapabilities) bool { + return caps.TextDocument.Definition.LinkSupport } -func getTypeDefinitionClientSupportsLink(params *lsproto.InitializeParams) bool { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil || - params.Capabilities.TextDocument.TypeDefinition == nil { - return false - } - return ptrIsTrue(params.Capabilities.TextDocument.TypeDefinition.LinkSupport) +func getTypeDefinitionClientSupportsLink(caps lsproto.FinalizedClientCapabilities) bool { + return caps.TextDocument.TypeDefinition.LinkSupport } -func getImplementationClientSupportsLink(params *lsproto.InitializeParams) bool { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil || - params.Capabilities.TextDocument.Implementation == nil { - return false - } - return ptrIsTrue(params.Capabilities.TextDocument.Implementation.LinkSupport) +func getImplementationClientSupportsLink(caps lsproto.FinalizedClientCapabilities) bool { + return caps.TextDocument.Implementation.LinkSupport } func getDocumentSymbolClientSupportsHierarchical(params *lsproto.InitializeParams) bool { From f25c9b0f241380615c3f45f12f7092e8173aacb9 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 11:13:49 -0800 Subject: [PATCH 2/8] Add to server kinda --- internal/lsp/server.go | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/internal/lsp/server.go b/internal/lsp/server.go index eaa1e3b120..dee55c8013 100644 --- a/internal/lsp/server.go +++ b/internal/lsp/server.go @@ -143,9 +143,10 @@ type Server struct { defaultLibraryPath string typingsLocation string - initializeParams *lsproto.InitializeParams - positionEncoding lsproto.PositionEncodingKind - locale language.Tag + initializeParams *lsproto.InitializeParams + clientCapabilities lsproto.FinalizedClientCapabilities + positionEncoding lsproto.PositionEncodingKind + locale language.Tag watchEnabled bool watcherID atomic.Uint32 @@ -585,6 +586,7 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ } s.initializeParams = params + s.clientCapabilities = lsproto.FinalizeClientCapabilities(params.Capabilities) s.positionEncoding = lsproto.PositionEncodingKindUTF16 if genCapabilities := s.initializeParams.Capabilities.General; genCapabilities != nil && genCapabilities.PositionEncodings != nil { @@ -690,10 +692,6 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ return response, nil } -func (s *Server) FinalizedClientCapabilities() lsproto.FinalizedClientCapabilities { - return lsproto.FinalizeClientCapabilities(s.initializeParams.Capabilities) -} - func (s *Server) handleInitialized(ctx context.Context, params *lsproto.InitializedParams) error { if shouldEnableWatch(s.initializeParams) { s.watchEnabled = true @@ -835,11 +833,11 @@ func (s *Server) handleSignatureHelp(ctx context.Context, languageService *ls.La } func (s *Server) handleDefinition(ctx context.Context, ls *ls.LanguageService, params *lsproto.DefinitionParams) (lsproto.DefinitionResponse, error) { - return ls.ProvideDefinition(ctx, params.TextDocument.Uri, params.Position, getDefinitionClientSupportsLink(s.FinalizedClientCapabilities())) + return ls.ProvideDefinition(ctx, params.TextDocument.Uri, params.Position, getDefinitionClientSupportsLink(s.clientCapabilities)) } func (s *Server) handleTypeDefinition(ctx context.Context, ls *ls.LanguageService, params *lsproto.TypeDefinitionParams) (lsproto.TypeDefinitionResponse, error) { - return ls.ProvideTypeDefinition(ctx, params.TextDocument.Uri, params.Position, getTypeDefinitionClientSupportsLink(s.FinalizedClientCapabilities())) + return ls.ProvideTypeDefinition(ctx, params.TextDocument.Uri, params.Position, getTypeDefinitionClientSupportsLink(s.clientCapabilities)) } func (s *Server) handleReferences(ctx context.Context, ls *ls.LanguageService, params *lsproto.ReferenceParams) (lsproto.ReferencesResponse, error) { @@ -849,7 +847,7 @@ func (s *Server) handleReferences(ctx context.Context, ls *ls.LanguageService, p func (s *Server) handleImplementations(ctx context.Context, ls *ls.LanguageService, params *lsproto.ImplementationParams) (lsproto.ImplementationResponse, error) { // goToImplementation - return ls.ProvideImplementations(ctx, params, getImplementationClientSupportsLink(s.FinalizedClientCapabilities())) + return ls.ProvideImplementations(ctx, params, getImplementationClientSupportsLink(s.clientCapabilities)) } func (s *Server) handleCompletion(ctx context.Context, languageService *ls.LanguageService, params *lsproto.CompletionParams) (lsproto.CompletionResponse, error) { From 2621a175920525242f396bd1ba6eb06a54480da9 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 12:48:26 -0800 Subject: [PATCH 3/8] some movement --- internal/lsp/lsproto/lsp.go | 14 ++++++++++++++ internal/lsp/server.go | 6 ++++-- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/internal/lsp/lsproto/lsp.go b/internal/lsp/lsproto/lsp.go index dd172077c2..4ddc26a291 100644 --- a/internal/lsp/lsproto/lsp.go +++ b/internal/lsp/lsproto/lsp.go @@ -1,6 +1,7 @@ package lsproto import ( + "context" "fmt" "net/url" "strings" @@ -149,3 +150,16 @@ func (Null) UnmarshalJSONFrom(dec *jsontext.Decoder) error { func (Null) MarshalJSONTo(enc *jsontext.Encoder) error { return enc.WriteToken(jsontext.Null) } + +type clientCapabilitiesKey struct{} + +func WithClientCapabilities(ctx context.Context, caps *FinalizedClientCapabilities) context.Context { + return context.WithValue(ctx, clientCapabilitiesKey{}, caps) +} + +func GetClientCapabilities(ctx context.Context) *FinalizedClientCapabilities { + if caps, _ := ctx.Value(clientCapabilitiesKey{}).(*FinalizedClientCapabilities); caps != nil { + return caps + } + return &FinalizedClientCapabilities{} +} diff --git a/internal/lsp/server.go b/internal/lsp/server.go index dee55c8013..015a1379e6 100644 --- a/internal/lsp/server.go +++ b/internal/lsp/server.go @@ -144,7 +144,7 @@ type Server struct { typingsLocation string initializeParams *lsproto.InitializeParams - clientCapabilities lsproto.FinalizedClientCapabilities + clientCapabilities *lsproto.FinalizedClientCapabilities positionEncoding lsproto.PositionEncodingKind locale language.Tag @@ -448,6 +448,8 @@ func (s *Server) sendResponse(resp *lsproto.ResponseMessage) { } func (s *Server) handleRequestOrNotification(ctx context.Context, req *lsproto.RequestMessage) error { + ctx = lsproto.WithClientCapabilities(ctx, s.clientCapabilities) + if handler := handlers()[req.Method]; handler != nil { return handler(s, ctx, req) } @@ -586,7 +588,7 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ } s.initializeParams = params - s.clientCapabilities = lsproto.FinalizeClientCapabilities(params.Capabilities) + s.clientCapabilities = ptrTo(lsproto.FinalizeClientCapabilities(params.Capabilities)) s.positionEncoding = lsproto.PositionEncodingKindUTF16 if genCapabilities := s.initializeParams.Capabilities.General; genCapabilities != nil && genCapabilities.PositionEncodings != nil { From 349052e083c9c3f9b0ec7ab4d2ec595b76c7d597 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 13:34:21 -0800 Subject: [PATCH 4/8] Plubm this through everything --- internal/ls/completions.go | 158 ++++++++++++----------------- internal/ls/definition.go | 15 ++- internal/ls/diagnostics.go | 15 +-- internal/ls/findallreferences.go | 4 +- internal/ls/hover.go | 5 +- internal/ls/signaturehelp.go | 19 ++-- internal/ls/string_completions.go | 18 ++-- internal/ls/symbols.go | 4 +- internal/lsp/lsproto/lsp.go | 9 ++ internal/lsp/server.go | 161 ++++++++---------------------- internal/project/untitled_test.go | 2 +- 11 files changed, 151 insertions(+), 259 deletions(-) diff --git a/internal/ls/completions.go b/internal/ls/completions.go index 1119aa3b86..97edbdf59f 100644 --- a/internal/ls/completions.go +++ b/internal/ls/completions.go @@ -36,7 +36,6 @@ func (l *LanguageService) ProvideCompletion( documentURI lsproto.DocumentUri, LSPPosition lsproto.Position, context *lsproto.CompletionContext, - clientOptions *lsproto.CompletionClientCapabilities, ) (lsproto.CompletionResponse, error) { _, file := l.getProgramAndFile(documentURI) var triggerCharacter *string @@ -49,7 +48,6 @@ func (l *LanguageService) ProvideCompletion( file, position, triggerCharacter, - clientOptions, ) completionList = ensureItemData(file.FileName(), position, completionList) return lsproto.CompletionItemsOrListOrNull{List: completionList}, nil @@ -342,7 +340,6 @@ func (l *LanguageService) getCompletionsAtPosition( file *ast.SourceFile, position int, triggerCharacter *string, - clientOptions *lsproto.CompletionClientCapabilities, ) *lsproto.CompletionList { _, previousToken := getRelevantTokens(position, file) if triggerCharacter != nil && !IsInString(file, position, previousToken) && !isValidTrigger(file, *triggerCharacter, previousToken, position) { @@ -369,7 +366,6 @@ func (l *LanguageService) getCompletionsAtPosition( position, previousToken, compilerOptions, - clientOptions, ) if stringCompletions != nil { return stringCompletions @@ -380,8 +376,8 @@ func (l *LanguageService) getCompletionsAtPosition( previousToken.Kind == ast.KindIdentifier) && ast.IsBreakOrContinueStatement(previousToken.Parent) { return l.getLabelCompletionsAtPosition( + ctx, previousToken.Parent, - clientOptions, file, position, l.getOptionalReplacementSpan(previousToken, file), @@ -406,7 +402,6 @@ func (l *LanguageService) getCompletionsAtPosition( compilerOptions, data, position, - clientOptions, optionalReplacementSpan, ) // !!! check if response is incomplete @@ -414,7 +409,7 @@ func (l *LanguageService) getCompletionsAtPosition( case *completionDataKeyword: optionalReplacementSpan := l.getOptionalReplacementSpan(previousToken, file) return l.specificKeywordCompletionInfo( - clientOptions, + ctx, position, file, data.keywordCompletions, @@ -425,7 +420,7 @@ func (l *LanguageService) getCompletionsAtPosition( // If the current position is a jsDoc tag name, only tag names should be provided for completion items := getJSDocTagNameCompletions() items = append(items, getJSDocParameterCompletions( - clientOptions, + ctx, file, position, checker, @@ -433,12 +428,12 @@ func (l *LanguageService) getCompletionsAtPosition( preferences, /*tagNameOnly*/ true, )...) - return l.jsDocCompletionInfo(clientOptions, position, file, items) + return l.jsDocCompletionInfo(ctx, position, file, items) case *completionDataJSDocTag: // If the current position is a jsDoc tag, only tags should be provided for completion items := getJSDocTagCompletions() items = append(items, getJSDocParameterCompletions( - clientOptions, + ctx, file, position, checker, @@ -446,9 +441,9 @@ func (l *LanguageService) getCompletionsAtPosition( preferences, /*tagNameOnly*/ false, )...) - return l.jsDocCompletionInfo(clientOptions, position, file, items) + return l.jsDocCompletionInfo(ctx, position, file, items) case *completionDataJSDocParameterName: - return l.jsDocCompletionInfo(clientOptions, position, file, getJSDocParameterNameCompletions(data.tag)) + return l.jsDocCompletionInfo(ctx, position, file, getJSDocParameterNameCompletions(data.tag)) default: panic("getCompletionData() returned unexpected type: " + fmt.Sprintf("%T", data)) } @@ -1818,7 +1813,6 @@ func (l *LanguageService) completionInfoFromData( compilerOptions *core.CompilerOptions, data *completionDataData, position int, - clientOptions *lsproto.CompletionClientCapabilities, optionalReplacementSpan *lsproto.Range, ) *lsproto.CompletionList { keywordFilters := data.keywordFilters @@ -1829,7 +1823,7 @@ func (l *LanguageService) completionInfoFromData( // Verify if the file is JSX language variant if file.LanguageVariant == core.LanguageVariantJSX { - list := l.getJsxClosingTagCompletion(data.location, file, position, clientOptions) + list := l.getJsxClosingTagCompletion(ctx, data.location, file, position) if list != nil { return list } @@ -1868,7 +1862,6 @@ func (l *LanguageService) completionInfoFromData( position, file, compilerOptions, - clientOptions, ) if data.keywordFilters != KeywordCompletionFiltersNone { @@ -1909,7 +1902,7 @@ func (l *LanguageService) completionInfoFromData( // !!! exhaustive case completions itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, sortedEntries, @@ -1931,7 +1924,6 @@ func (l *LanguageService) getCompletionEntriesFromSymbols( position int, file *ast.SourceFile, compilerOptions *core.CompilerOptions, - clientOptions *lsproto.CompletionClientCapabilities, ) (uniqueNames collections.Set[string], sortedEntries []*lsproto.CompletionItem) { closestSymbolDeclaration := getClosestSymbolDeclaration(data.contextToken, data.location) useSemicolons := lsutil.ProbablyUsesSemicolons(file) @@ -1988,7 +1980,6 @@ func (l *LanguageService) getCompletionEntriesFromSymbols( origin, useSemicolons, compilerOptions, - clientOptions, isMemberCompletion, ) if entry == nil { @@ -2054,9 +2045,9 @@ func (l *LanguageService) createCompletionItem( origin *symbolOriginInfo, useSemicolons bool, compilerOptions *core.CompilerOptions, - clientOptions *lsproto.CompletionClientCapabilities, isMemberCompletion bool, ) *lsproto.CompletionItem { + clientOptions := lsproto.GetClientCapabilities(ctx).TextDocument.Completion contextToken := data.contextToken var insertText string var filterText string @@ -2173,7 +2164,7 @@ func (l *LanguageService) createCompletionItem( if data.importStatementCompletion.isTopLevelTypeOnly { insertText += typeOnlyText } - tabStop := core.IfElse(ptrIsTrue(clientOptions.CompletionItem.SnippetSupport), "$1", "") + tabStop := core.IfElse(clientOptions.CompletionItem.SnippetSupport, "$1", "") importKind := getImportKind(file, exportKind, l.GetProgram(), true /*forceImportKeyword*/) escapedSnippet := escapeSnippetText(name) suffix := core.IfElse(useSemicolons, ";", "") @@ -2190,7 +2181,7 @@ func (l *LanguageService) createCompletionItem( } replacementSpan = data.importStatementCompletion.replacementSpan - isSnippet = ptrIsTrue(clientOptions.CompletionItem.SnippetSupport) + isSnippet = clientOptions.CompletionItem.SnippetSupport } } @@ -2234,7 +2225,7 @@ func (l *LanguageService) createCompletionItem( insertText = origin.asObjectLiteralMethod().insertText isSnippet = origin.asObjectLiteralMethod().isSnippet labelDetails = origin.asObjectLiteralMethod().labelDetails // !!! check if this can conflict with case above where we set label details - if !clientSupportsItemLabelDetails(clientOptions) { + if !clientSupportsItemLabelDetails(ctx) { name = name + *origin.asObjectLiteralMethod().labelDetails.Detail labelDetails = nil } @@ -2244,7 +2235,7 @@ func (l *LanguageService) createCompletionItem( if data.isJsxIdentifierExpected && !data.isRightOfOpenTag && - clientSupportsItemSnippet(clientOptions) && + clientSupportsItemSnippet(ctx) && preferences.JsxAttributeCompletionStyle != lsutil.JsxAttributeCompletionStyleNone && !(ast.IsJsxAttribute(data.location.Parent) && data.location.Parent.Initializer() != nil) { useBraces := preferences.JsxAttributeCompletionStyle == lsutil.JsxAttributeCompletionStyleBraces @@ -2311,10 +2302,10 @@ func (l *LanguageService) createCompletionItem( elementKind := getSymbolKind(typeChecker, symbol, data.location) var commitCharacters *[]string - if clientSupportsItemCommitCharacters(clientOptions) { + if clientSupportsItemCommitCharacters(ctx) { if elementKind == ScriptElementKindWarning || elementKind == ScriptElementKindString { commitCharacters = &[]string{} - } else if !clientSupportsDefaultCommitCharacters(clientOptions) { + } else if !clientSupportsDefaultCommitCharacters(ctx) { commitCharacters = ptrTo(data.defaultCommitCharacters) } // Otherwise use the completion list default. @@ -2324,6 +2315,7 @@ func (l *LanguageService) createCompletionItem( kindModifiers := getSymbolModifiers(typeChecker, symbol) return l.createLSPCompletionItem( + ctx, name, insertText, filterText, @@ -2335,7 +2327,6 @@ func (l *LanguageService) createCompletionItem( labelDetails, file, position, - clientOptions, isMemberCompletion, isSnippet, hasAction, @@ -4315,7 +4306,7 @@ func isTypeKeywordTokenOrIdentifier(node *ast.Node) bool { // Returns the item defaults for completion items, if that capability is supported. // Otherwise, if some item default is not supported by client, sets that property on each item. func (l *LanguageService) setItemDefaults( - clientOptions *lsproto.CompletionClientCapabilities, + ctx context.Context, position int, file *ast.SourceFile, items []*lsproto.CompletionItem, @@ -4324,8 +4315,8 @@ func (l *LanguageService) setItemDefaults( ) *lsproto.CompletionItemDefaults { var itemDefaults *lsproto.CompletionItemDefaults if defaultCommitCharacters != nil { - supportsItemCommitCharacters := clientSupportsItemCommitCharacters(clientOptions) - if clientSupportsDefaultCommitCharacters(clientOptions) && supportsItemCommitCharacters { + supportsItemCommitCharacters := clientSupportsItemCommitCharacters(ctx) + if clientSupportsDefaultCommitCharacters(ctx) && supportsItemCommitCharacters { itemDefaults = &lsproto.CompletionItemDefaults{ CommitCharacters: defaultCommitCharacters, } @@ -4343,7 +4334,7 @@ func (l *LanguageService) setItemDefaults( Start: optionalReplacementSpan.Start, End: l.createLspPosition(position, file), } - if clientSupportsDefaultEditRange(clientOptions) { + if clientSupportsDefaultEditRange(ctx) { itemDefaults = core.OrElse(itemDefaults, &lsproto.CompletionItemDefaults{}) itemDefaults.EditRange = &lsproto.RangeOrEditRangeWithInsertReplace{ EditRangeWithInsertReplace: &lsproto.EditRangeWithInsertReplace{ @@ -4365,7 +4356,7 @@ func (l *LanguageService) setItemDefaults( item.InsertText = nil } } - } else if clientSupportsItemInsertReplace(clientOptions) { + } else if clientSupportsItemInsertReplace(ctx) { for _, item := range items { if item.TextEdit == nil { item.TextEdit = &lsproto.TextEditOrInsertReplaceEdit{ @@ -4384,7 +4375,7 @@ func (l *LanguageService) setItemDefaults( } func (l *LanguageService) specificKeywordCompletionInfo( - clientOptions *lsproto.CompletionClientCapabilities, + ctx context.Context, position int, file *ast.SourceFile, items []*lsproto.CompletionItem, @@ -4393,7 +4384,7 @@ func (l *LanguageService) specificKeywordCompletionInfo( ) *lsproto.CompletionList { defaultCommitCharacters := getDefaultCommitCharacters(isNewIdentifierLocation) itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, @@ -4408,10 +4399,10 @@ func (l *LanguageService) specificKeywordCompletionInfo( } func (l *LanguageService) getJsxClosingTagCompletion( + ctx context.Context, location *ast.Node, file *ast.SourceFile, position int, - clientOptions *lsproto.CompletionClientCapabilities, ) *lsproto.CompletionList { // We wanna walk up the tree till we find a JSX closing element. jsxClosingElement := ast.FindAncestorOrQuit(location, func(node *ast.Node) ast.FindAncestorResult { @@ -4449,6 +4440,7 @@ func (l *LanguageService) getJsxClosingTagCompletion( defaultCommitCharacters := getDefaultCommitCharacters(false /*isNewIdentifierLocation*/) item := l.createLSPCompletionItem( + ctx, fullClosingTag, /*name*/ "", /*insertText*/ "", /*filterText*/ @@ -4460,7 +4452,6 @@ func (l *LanguageService) getJsxClosingTagCompletion( nil, /*labelDetails*/ file, position, - clientOptions, true, /*isMemberCompletion*/ false, /*isSnippet*/ false, /*hasAction*/ @@ -4470,7 +4461,7 @@ func (l *LanguageService) getJsxClosingTagCompletion( ) items := []*lsproto.CompletionItem{item} itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, @@ -4486,6 +4477,7 @@ func (l *LanguageService) getJsxClosingTagCompletion( } func (l *LanguageService) createLSPCompletionItem( + ctx context.Context, name string, insertText string, filterText string, @@ -4497,7 +4489,6 @@ func (l *LanguageService) createLSPCompletionItem( labelDetails *lsproto.CompletionItemLabelDetails, file *ast.SourceFile, position int, - clientOptions *lsproto.CompletionClientCapabilities, isMemberCompletion bool, isSnippet bool, hasAction bool, @@ -4591,19 +4582,19 @@ func (l *LanguageService) createLSPCompletionItem( } func (l *LanguageService) getLabelCompletionsAtPosition( + ctx context.Context, node *ast.BreakOrContinueStatement, - clientOptions *lsproto.CompletionClientCapabilities, file *ast.SourceFile, position int, optionalReplacementSpan *lsproto.Range, ) *lsproto.CompletionList { - items := l.getLabelStatementCompletions(node, clientOptions, file, position) + items := l.getLabelStatementCompletions(ctx, node, file, position) if len(items) == 0 { return nil } defaultCommitCharacters := getDefaultCommitCharacters(false /*isNewIdentifierLocation*/) itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, @@ -4618,8 +4609,8 @@ func (l *LanguageService) getLabelCompletionsAtPosition( } func (l *LanguageService) getLabelStatementCompletions( + ctx context.Context, node *ast.BreakOrContinueStatement, - clientOptions *lsproto.CompletionClientCapabilities, file *ast.SourceFile, position int, ) []*lsproto.CompletionItem { @@ -4635,6 +4626,7 @@ func (l *LanguageService) getLabelStatementCompletions( if !uniques.Has(name) { uniques.Add(name) items = append(items, l.createLSPCompletionItem( + ctx, name, "", /*insertText*/ "", /*filterText*/ @@ -4646,7 +4638,6 @@ func (l *LanguageService) getLabelStatementCompletions( nil, /*labelDetails*/ file, position, - clientOptions, false, /*isMemberCompletion*/ false, /*isSnippet*/ false, /*hasAction*/ @@ -4886,38 +4877,28 @@ func isInJsxText(contextToken *ast.Node, location *ast.Node) bool { return false } -func hasCompletionItem(clientOptions *lsproto.CompletionClientCapabilities) bool { - return clientOptions != nil && clientOptions.CompletionItem != nil -} - -func clientSupportsItemLabelDetails(clientOptions *lsproto.CompletionClientCapabilities) bool { - return hasCompletionItem(clientOptions) && ptrIsTrue(clientOptions.CompletionItem.LabelDetailsSupport) +func clientSupportsItemLabelDetails(ctx context.Context) bool { + return lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionItem.LabelDetailsSupport } -func clientSupportsItemSnippet(clientOptions *lsproto.CompletionClientCapabilities) bool { - return hasCompletionItem(clientOptions) && ptrIsTrue(clientOptions.CompletionItem.SnippetSupport) +func clientSupportsItemSnippet(ctx context.Context) bool { + return lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionItem.SnippetSupport } -func clientSupportsItemCommitCharacters(clientOptions *lsproto.CompletionClientCapabilities) bool { - return hasCompletionItem(clientOptions) && ptrIsTrue(clientOptions.CompletionItem.CommitCharactersSupport) +func clientSupportsItemCommitCharacters(ctx context.Context) bool { + return lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionItem.CommitCharactersSupport } -func clientSupportsItemInsertReplace(clientOptions *lsproto.CompletionClientCapabilities) bool { - return hasCompletionItem(clientOptions) && ptrIsTrue(clientOptions.CompletionItem.InsertReplaceSupport) +func clientSupportsItemInsertReplace(ctx context.Context) bool { + return lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionItem.InsertReplaceSupport } -func clientSupportsDefaultCommitCharacters(clientOptions *lsproto.CompletionClientCapabilities) bool { - if clientOptions == nil || clientOptions.CompletionList == nil || clientOptions.CompletionList.ItemDefaults == nil { - return false - } - return slices.Contains(*clientOptions.CompletionList.ItemDefaults, "commitCharacters") +func clientSupportsDefaultCommitCharacters(ctx context.Context) bool { + return slices.Contains(lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionList.ItemDefaults, "commitCharacters") } -func clientSupportsDefaultEditRange(clientOptions *lsproto.CompletionClientCapabilities) bool { - if clientOptions == nil || clientOptions.CompletionList == nil || clientOptions.CompletionList.ItemDefaults == nil { - return false - } - return slices.Contains(*clientOptions.CompletionList.ItemDefaults, "editRange") +func clientSupportsDefaultEditRange(ctx context.Context) bool { + return slices.Contains(lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionList.ItemDefaults, "editRange") } type argumentInfoForCompletions struct { @@ -5002,7 +4983,6 @@ func (l *LanguageService) ResolveCompletionItem( ctx context.Context, item *lsproto.CompletionItem, data *CompletionItemData, - clientOptions *lsproto.CompletionClientCapabilities, ) (*lsproto.CompletionItem, error) { if data == nil { return nil, errors.New("completion item data is nil") @@ -5013,7 +4993,7 @@ func (l *LanguageService) ResolveCompletionItem( return nil, fmt.Errorf("file not found: %s", data.FileName) } - return l.getCompletionItemDetails(ctx, program, data.Position, file, item, data, clientOptions), nil + return l.getCompletionItemDetails(ctx, program, data.Position, file, item, data), nil } func GetCompletionItemData(item *lsproto.CompletionItem) (*CompletionItemData, error) { @@ -5028,17 +5008,8 @@ func GetCompletionItemData(item *lsproto.CompletionItem) (*CompletionItemData, e return &itemData, nil } -func getCompletionDocumentationFormat(clientOptions *lsproto.CompletionClientCapabilities) lsproto.MarkupKind { - if clientOptions == nil || clientOptions.CompletionItem == nil || clientOptions.CompletionItem.DocumentationFormat == nil { - // Default to plaintext if no preference specified - return lsproto.MarkupKindPlainText - } - formats := *clientOptions.CompletionItem.DocumentationFormat - if len(formats) == 0 { - return lsproto.MarkupKindPlainText - } - // Return the first (most preferred) format - return formats[0] +func getCompletionDocumentationFormat(ctx context.Context) lsproto.MarkupKind { + return lsproto.PreferredMarkupKind(lsproto.GetClientCapabilities(ctx).TextDocument.Completion.CompletionItem.DocumentationFormat) } func (l *LanguageService) getCompletionItemDetails( @@ -5047,19 +5018,18 @@ func (l *LanguageService) getCompletionItemDetails( position int, file *ast.SourceFile, item *lsproto.CompletionItem, - itemData *CompletionItemData, - clientOptions *lsproto.CompletionClientCapabilities, + data *CompletionItemData, ) *lsproto.CompletionItem { checker, done := program.GetTypeCheckerForFile(ctx, file) defer done() - docFormat := getCompletionDocumentationFormat(clientOptions) + docFormat := getCompletionDocumentationFormat(ctx) contextToken, previousToken := getRelevantTokens(position, file) if IsInString(file, position, previousToken) { return l.getStringLiteralCompletionDetails( ctx, checker, item, - itemData.Name, + data.Name, file, position, contextToken, @@ -5073,8 +5043,7 @@ func (l *LanguageService) getCompletionItemDetails( checker, file, position, - itemData, - clientOptions, + data, ) preferences := l.UserPreferences() @@ -5083,16 +5052,16 @@ func (l *LanguageService) getCompletionItemDetails( request := *symbolCompletion.request switch request := request.(type) { case *completionDataJSDocTagName: - return createSimpleDetails(item, itemData.Name, docFormat) + return createSimpleDetails(item, data.Name, docFormat) case *completionDataJSDocTag: - return createSimpleDetails(item, itemData.Name, docFormat) + return createSimpleDetails(item, data.Name, docFormat) case *completionDataJSDocParameterName: - return createSimpleDetails(item, itemData.Name, docFormat) + return createSimpleDetails(item, data.Name, docFormat) case *completionDataKeyword: if core.Some(request.keywordCompletions, func(c *lsproto.CompletionItem) bool { - return c.Label == itemData.Name + return c.Label == data.Name }) { - return createSimpleDetails(item, itemData.Name, docFormat) + return createSimpleDetails(item, data.Name, docFormat) } return item default: @@ -5100,7 +5069,7 @@ func (l *LanguageService) getCompletionItemDetails( } case symbolCompletion.symbol != nil: symbolDetails := symbolCompletion.symbol - actions := l.getCompletionItemActions(ctx, checker, file, position, itemData, symbolDetails) + actions := l.getCompletionItemActions(ctx, checker, file, position, data, symbolDetails) return l.createCompletionDetailsForSymbol( item, symbolDetails.symbol, @@ -5118,9 +5087,9 @@ func (l *LanguageService) getCompletionItemDetails( default: // Didn't find a symbol with this name. See if we can find a keyword instead. if core.Some(allKeywordCompletions(), func(c *lsproto.CompletionItem) bool { - return c.Label == itemData.Name + return c.Label == data.Name }) { - return createSimpleDetails(item, itemData.Name, docFormat) + return createSimpleDetails(item, data.Name, docFormat) } return item } @@ -5149,7 +5118,6 @@ func (l *LanguageService) getSymbolCompletionFromItemData( file *ast.SourceFile, position int, itemData *CompletionItemData, - clientOptions *lsproto.CompletionClientCapabilities, ) detailsData { if itemData.Source == SourceSwitchCases { return detailsData{ @@ -5601,14 +5569,14 @@ func isTagWithTypeExpression(tag *ast.JSDocTag) bool { } func (l *LanguageService) jsDocCompletionInfo( - clientOptions *lsproto.CompletionClientCapabilities, + ctx context.Context, position int, file *ast.SourceFile, items []*lsproto.CompletionItem, ) *lsproto.CompletionList { defaultCommitCharacters := getDefaultCommitCharacters(false /*isNewIdentifierLocation*/) itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, @@ -5744,7 +5712,7 @@ func getJSDocTagCompletions() []*lsproto.CompletionItem { } func getJSDocParameterCompletions( - clientOptions *lsproto.CompletionClientCapabilities, + ctx context.Context, file *ast.SourceFile, position int, typeChecker *checker.Checker, diff --git a/internal/ls/definition.go b/internal/ls/definition.go index 9f0d231fc7..fb9e8164a6 100644 --- a/internal/ls/definition.go +++ b/internal/ls/definition.go @@ -17,8 +17,10 @@ func (l *LanguageService) ProvideDefinition( ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position, - clientSupportsLink bool, ) (lsproto.DefinitionResponse, error) { + caps := lsproto.GetClientCapabilities(ctx) + clientSupportsLink := caps.TextDocument.Definition.LinkSupport + program, file := l.getProgramAndFile(documentURI) node := astnav.GetTouchingPropertyName(file, int(l.converters.LineAndCharacterToPosition(file, position))) if node.Kind == ast.KindSourceFile { @@ -68,8 +70,10 @@ func (l *LanguageService) ProvideTypeDefinition( ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position, - clientSupportsLink bool, -) (lsproto.DefinitionResponse, error) { +) (lsproto.TypeDefinitionResponse, error) { + caps := lsproto.GetClientCapabilities(ctx) + clientSupportsLink := caps.TextDocument.TypeDefinition.LinkSupport + program, file := l.getProgramAndFile(documentURI) node := astnav.GetTouchingPropertyName(file, int(l.converters.LineAndCharacterToPosition(file, position))) if node.Kind == ast.KindSourceFile { @@ -279,8 +283,3 @@ func getDeclarationsFromType(t *checker.Type) []*ast.Node { } return result } - -func clientSupportsLink(clientCapabilities *lsproto.DefinitionClientCapabilities) bool { - return clientCapabilities != nil && - ptrIsTrue(clientCapabilities.LinkSupport) -} diff --git a/internal/ls/diagnostics.go b/internal/ls/diagnostics.go index 28df9c80bb..59d34bb213 100644 --- a/internal/ls/diagnostics.go +++ b/internal/ls/diagnostics.go @@ -12,7 +12,7 @@ import ( "github.com/microsoft/typescript-go/internal/lsp/lsproto" ) -func (l *LanguageService) ProvideDiagnostics(ctx context.Context, uri lsproto.DocumentUri, clientOptions *lsproto.DiagnosticClientCapabilities) (lsproto.DocumentDiagnosticResponse, error) { +func (l *LanguageService) ProvideDiagnostics(ctx context.Context, uri lsproto.DocumentUri) (lsproto.DocumentDiagnosticResponse, error) { program, file := l.getProgramAndFile(uri) diagnostics := make([][]*ast.Diagnostic, 0, 4) @@ -28,12 +28,12 @@ func (l *LanguageService) ProvideDiagnostics(ctx context.Context, uri lsproto.Do return lsproto.RelatedFullDocumentDiagnosticReportOrUnchangedDocumentDiagnosticReport{ FullDocumentDiagnosticReport: &lsproto.RelatedFullDocumentDiagnosticReport{ - Items: l.toLSPDiagnostics(clientOptions, diagnostics...), + Items: l.toLSPDiagnostics(ctx, diagnostics...), }, }, nil } -func (l *LanguageService) toLSPDiagnostics(clientOptions *lsproto.DiagnosticClientCapabilities, diagnostics ...[]*ast.Diagnostic) []*lsproto.Diagnostic { +func (l *LanguageService) toLSPDiagnostics(ctx context.Context, diagnostics ...[]*ast.Diagnostic) []*lsproto.Diagnostic { size := 0 for _, diagSlice := range diagnostics { size += len(diagSlice) @@ -41,13 +41,14 @@ func (l *LanguageService) toLSPDiagnostics(clientOptions *lsproto.DiagnosticClie lspDiagnostics := make([]*lsproto.Diagnostic, 0, size) for _, diagSlice := range diagnostics { for _, diag := range diagSlice { - lspDiagnostics = append(lspDiagnostics, l.toLSPDiagnostic(clientOptions, diag)) + lspDiagnostics = append(lspDiagnostics, l.toLSPDiagnostic(ctx, diag)) } } return lspDiagnostics } -func (l *LanguageService) toLSPDiagnostic(clientOptions *lsproto.DiagnosticClientCapabilities, diagnostic *ast.Diagnostic) *lsproto.Diagnostic { +func (l *LanguageService) toLSPDiagnostic(ctx context.Context, diagnostic *ast.Diagnostic) *lsproto.Diagnostic { + clientOptions := lsproto.GetClientCapabilities(ctx).TextDocument.Diagnostic var severity lsproto.DiagnosticSeverity switch diagnostic.Category() { case diagnostics.CategorySuggestion: @@ -61,7 +62,7 @@ func (l *LanguageService) toLSPDiagnostic(clientOptions *lsproto.DiagnosticClien } var relatedInformation []*lsproto.DiagnosticRelatedInformation - if clientOptions != nil && ptrIsTrue(clientOptions.RelatedInformation) { + if clientOptions.RelatedInformation { relatedInformation = make([]*lsproto.DiagnosticRelatedInformation, 0, len(diagnostic.RelatedInformation())) for _, related := range diagnostic.RelatedInformation() { relatedInformation = append(relatedInformation, &lsproto.DiagnosticRelatedInformation{ @@ -75,7 +76,7 @@ func (l *LanguageService) toLSPDiagnostic(clientOptions *lsproto.DiagnosticClien } var tags []lsproto.DiagnosticTag - if clientOptions != nil && clientOptions.TagSupport != nil && (diagnostic.ReportsUnnecessary() || diagnostic.ReportsDeprecated()) { + if len(clientOptions.TagSupport.ValueSet) > 0 && (diagnostic.ReportsUnnecessary() || diagnostic.ReportsDeprecated()) { tags = make([]lsproto.DiagnosticTag, 0, 2) if diagnostic.ReportsUnnecessary() && slices.Contains(clientOptions.TagSupport.ValueSet, lsproto.DiagnosticTagUnnecessary) { tags = append(tags, lsproto.DiagnosticTagUnnecessary) diff --git a/internal/ls/findallreferences.go b/internal/ls/findallreferences.go index 545b274993..85d18cee0e 100644 --- a/internal/ls/findallreferences.go +++ b/internal/ls/findallreferences.go @@ -430,7 +430,7 @@ func (l *LanguageService) ProvideReferences(ctx context.Context, params *lsproto return lsproto.LocationsOrNull{Locations: &locations}, nil } -func (l *LanguageService) ProvideImplementations(ctx context.Context, params *lsproto.ImplementationParams, clientSupportsLink bool) (lsproto.ImplementationResponse, error) { +func (l *LanguageService) ProvideImplementations(ctx context.Context, params *lsproto.ImplementationParams) (lsproto.ImplementationResponse, error) { program, sourceFile := l.getProgramAndFile(params.TextDocument.Uri) position := int(l.converters.LineAndCharacterToPosition(sourceFile, params.Position)) node := astnav.GetTouchingPropertyName(sourceFile, position) @@ -452,7 +452,7 @@ func (l *LanguageService) ProvideImplementations(ctx context.Context, params *ls } } - if clientSupportsLink { + if lsproto.GetClientCapabilities(ctx).TextDocument.Implementation.LinkSupport { links := l.convertEntriesToLocationLinks(entries) return lsproto.LocationOrLocationsOrDefinitionLinksOrNull{DefinitionLinks: &links}, nil } diff --git a/internal/ls/hover.go b/internal/ls/hover.go index 808efe7dbf..736f4c31a9 100644 --- a/internal/ls/hover.go +++ b/internal/ls/hover.go @@ -18,7 +18,10 @@ const ( typeFormatFlags = checker.TypeFormatFlagsUseAliasDefinedOutsideCurrentScope ) -func (l *LanguageService) ProvideHover(ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position, contentFormat lsproto.MarkupKind) (lsproto.HoverResponse, error) { +func (l *LanguageService) ProvideHover(ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position) (lsproto.HoverResponse, error) { + caps := lsproto.GetClientCapabilities(ctx) + contentFormat := lsproto.PreferredMarkupKind(caps.TextDocument.Hover.ContentFormat) + program, file := l.getProgramAndFile(documentURI) node := astnav.GetTouchingPropertyName(file, int(l.converters.LineAndCharacterToPosition(file, position))) if node.Kind == ast.KindSourceFile { diff --git a/internal/ls/signaturehelp.go b/internal/ls/signaturehelp.go index 508c74877a..6a4289b28b 100644 --- a/internal/ls/signaturehelp.go +++ b/internal/ls/signaturehelp.go @@ -43,8 +43,6 @@ func (l *LanguageService) ProvideSignatureHelp( documentURI lsproto.DocumentUri, position lsproto.Position, context *lsproto.SignatureHelpContext, - clientOptions *lsproto.SignatureHelpClientCapabilities, - docFormat lsproto.MarkupKind, ) (lsproto.SignatureHelpResponse, error) { program, sourceFile := l.getProgramAndFile(documentURI) items := l.GetSignatureHelpItems( @@ -52,9 +50,7 @@ func (l *LanguageService) ProvideSignatureHelp( int(l.converters.LineAndCharacterToPosition(sourceFile, position)), program, sourceFile, - context, - clientOptions, - docFormat) + context) return lsproto.SignatureHelpOrNull{SignatureHelp: items}, nil } @@ -64,8 +60,6 @@ func (l *LanguageService) GetSignatureHelpItems( program *compiler.Program, sourceFile *ast.SourceFile, context *lsproto.SignatureHelpContext, - clientOptions *lsproto.SignatureHelpClientCapabilities, - docFormat lsproto.MarkupKind, ) *lsproto.SignatureHelp { typeChecker, done := program.GetTypeCheckerForFile(ctx, sourceFile) defer done() @@ -143,12 +137,12 @@ func (l *LanguageService) GetSignatureHelpItems( // return typeChecker.runWithCancellationToken(cancellationToken, typeChecker => if candidateInfo.candidateInfo != nil { - return l.createSignatureHelpItems(candidateInfo.candidateInfo.candidates, candidateInfo.candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker, onlyUseSyntacticOwners, clientOptions, docFormat) + return l.createSignatureHelpItems(ctx, candidateInfo.candidateInfo.candidates, candidateInfo.candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker, onlyUseSyntacticOwners) } - return createTypeHelpItems(candidateInfo.typeInfo, argumentInfo, sourceFile, clientOptions, typeChecker) + return createTypeHelpItems(candidateInfo.typeInfo, argumentInfo, sourceFile, typeChecker) } -func createTypeHelpItems(symbol *ast.Symbol, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, clientOptions *lsproto.SignatureHelpClientCapabilities, c *checker.Checker) *lsproto.SignatureHelp { +func createTypeHelpItems(symbol *ast.Symbol, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker) *lsproto.SignatureHelp { typeParameters := c.GetLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) if typeParameters == nil { return nil @@ -205,7 +199,10 @@ func getTypeHelpItem(symbol *ast.Symbol, typeParameter []*checker.Type, enclosin } } -func (l *LanguageService) createSignatureHelpItems(candidates []*checker.Signature, resolvedSignature *checker.Signature, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker, useFullPrefix bool, clientOptions *lsproto.SignatureHelpClientCapabilities, docFormat lsproto.MarkupKind) *lsproto.SignatureHelp { +func (l *LanguageService) createSignatureHelpItems(ctx context.Context,candidates []*checker.Signature, resolvedSignature *checker.Signature, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker, useFullPrefix bool) *lsproto.SignatureHelp { + caps := lsproto.GetClientCapabilities(ctx) + docFormat := lsproto.PreferredMarkupKind(caps.TextDocument.SignatureHelp.SignatureInformation.DocumentationFormat) + enclosingDeclaration := getEnclosingDeclarationFromInvocation(argumentInfo.invocation) if enclosingDeclaration == nil { return nil diff --git a/internal/ls/string_completions.go b/internal/ls/string_completions.go index 35d8b697da..a27b3768ef 100644 --- a/internal/ls/string_completions.go +++ b/internal/ls/string_completions.go @@ -46,7 +46,6 @@ func (l *LanguageService) getStringLiteralCompletions( position int, contextToken *ast.Node, compilerOptions *core.CompilerOptions, - clientOptions *lsproto.CompletionClientCapabilities, ) *lsproto.CompletionList { // !!! reference comment if IsInString(file, position, contextToken) { @@ -65,7 +64,6 @@ func (l *LanguageService) getStringLiteralCompletions( file, position, compilerOptions, - clientOptions, ) } return nil @@ -78,7 +76,6 @@ func (l *LanguageService) convertStringLiteralCompletions( file *ast.SourceFile, position int, options *core.CompilerOptions, - clientOptions *lsproto.CompletionClientCapabilities, ) *lsproto.CompletionList { if completion == nil { return nil @@ -88,7 +85,7 @@ func (l *LanguageService) convertStringLiteralCompletions( switch { case completion.fromPaths != nil: completion := completion.fromPaths - return l.convertPathCompletions(completion, file, position, clientOptions) + return l.convertPathCompletions(ctx, completion, file, position) case completion.fromProperties != nil: completion := completion.fromProperties data := &completionDataData{ @@ -105,11 +102,10 @@ func (l *LanguageService) convertStringLiteralCompletions( position, file, options, - clientOptions, ) defaultCommitCharacters := getDefaultCommitCharacters(completion.hasIndexSignature) itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, @@ -134,6 +130,7 @@ func (l *LanguageService) convertStringLiteralCompletions( items := core.Map(completion.types, func(t *checker.StringLiteralType) *lsproto.CompletionItem { name := printer.EscapeString(t.AsLiteralType().Value().(string), quoteChar) return l.createLSPCompletionItem( + ctx, name, "", /*insertText*/ "", /*filterText*/ @@ -145,7 +142,6 @@ func (l *LanguageService) convertStringLiteralCompletions( nil, /*labelDetails*/ file, position, - clientOptions, false, /*isMemberCompletion*/ false, /*isSnippet*/ false, /*hasAction*/ @@ -156,7 +152,7 @@ func (l *LanguageService) convertStringLiteralCompletions( }) defaultCommitCharacters := getDefaultCommitCharacters(completion.isNewIdentifier) itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, @@ -174,16 +170,17 @@ func (l *LanguageService) convertStringLiteralCompletions( } func (l *LanguageService) convertPathCompletions( + ctx context.Context, pathCompletions []*pathCompletion, file *ast.SourceFile, position int, - clientOptions *lsproto.CompletionClientCapabilities, ) *lsproto.CompletionList { isNewIdentifierLocation := true // The user may type in a path that doesn't yet exist, creating a "new identifier" with respect to the collection of identifiers the server is aware of. defaultCommitCharacters := getDefaultCommitCharacters(isNewIdentifierLocation) items := core.Map(pathCompletions, func(pathCompletion *pathCompletion) *lsproto.CompletionItem { replacementSpan := l.createLspRangeFromBounds(pathCompletion.textRange.Pos(), pathCompletion.textRange.End(), file) return l.createLSPCompletionItem( + ctx, pathCompletion.name, "", /*insertText*/ "", /*filterText*/ @@ -195,7 +192,6 @@ func (l *LanguageService) convertPathCompletions( nil, /*labelDetails*/ file, position, - clientOptions, false, /*isMemberCompletion*/ false, /*isSnippet*/ false, /*hasAction*/ @@ -205,7 +201,7 @@ func (l *LanguageService) convertPathCompletions( ) }) itemDefaults := l.setItemDefaults( - clientOptions, + ctx, position, file, items, diff --git a/internal/ls/symbols.go b/internal/ls/symbols.go index 98215dca31..5cab43634a 100644 --- a/internal/ls/symbols.go +++ b/internal/ls/symbols.go @@ -18,9 +18,9 @@ import ( "github.com/microsoft/typescript-go/internal/stringutil" ) -func (l *LanguageService) ProvideDocumentSymbols(ctx context.Context, documentURI lsproto.DocumentUri, hierarchicalSupport bool) (lsproto.DocumentSymbolResponse, error) { +func (l *LanguageService) ProvideDocumentSymbols(ctx context.Context, documentURI lsproto.DocumentUri) (lsproto.DocumentSymbolResponse, error) { _, file := l.getProgramAndFile(documentURI) - if hierarchicalSupport { + if lsproto.GetClientCapabilities(ctx).TextDocument.DocumentSymbol.HierarchicalDocumentSymbolSupport { symbols := l.getDocumentSymbolsForChildren(ctx, file.AsNode()) return lsproto.SymbolInformationsOrDocumentSymbolsOrNull{DocumentSymbols: &symbols}, nil } diff --git a/internal/lsp/lsproto/lsp.go b/internal/lsp/lsproto/lsp.go index 4ddc26a291..c4b4f91697 100644 --- a/internal/lsp/lsproto/lsp.go +++ b/internal/lsp/lsproto/lsp.go @@ -163,3 +163,12 @@ func GetClientCapabilities(ctx context.Context) *FinalizedClientCapabilities { } return &FinalizedClientCapabilities{} } + +// PreferredMarkupKind returns the first (most preferred) markup kind from the given formats, +// or MarkupKindPlainText if the slice is empty. +func PreferredMarkupKind(formats []MarkupKind) MarkupKind { + if len(formats) > 0 { + return formats[0] + } + return MarkupKindPlainText +} diff --git a/internal/lsp/server.go b/internal/lsp/server.go index 015a1379e6..0a283d7415 100644 --- a/internal/lsp/server.go +++ b/internal/lsp/server.go @@ -144,7 +144,7 @@ type Server struct { typingsLocation string initializeParams *lsproto.InitializeParams - clientCapabilities *lsproto.FinalizedClientCapabilities + clientCapabilities lsproto.FinalizedClientCapabilities positionEncoding lsproto.PositionEncodingKind locale language.Tag @@ -207,10 +207,7 @@ func (s *Server) UnwatchFiles(ctx context.Context, id project.WatcherID) error { // RefreshDiagnostics implements project.Client. func (s *Server) RefreshDiagnostics(ctx context.Context) error { - if s.initializeParams.Capabilities == nil || - s.initializeParams.Capabilities.Workspace == nil || - s.initializeParams.Capabilities.Workspace.Diagnostics == nil || - !ptrIsTrue(s.initializeParams.Capabilities.Workspace.Diagnostics.RefreshSupport) { + if !s.clientCapabilities.Workspace.Diagnostics.RefreshSupport { return nil } @@ -222,8 +219,8 @@ func (s *Server) RefreshDiagnostics(ctx context.Context) error { } func (s *Server) RequestConfiguration(ctx context.Context) (*lsutil.UserPreferences, error) { - if s.initializeParams.Capabilities == nil || s.initializeParams.Capabilities.Workspace == nil || - !ptrIsTrue(s.initializeParams.Capabilities.Workspace.Configuration) { + caps := lsproto.GetClientCapabilities(ctx) + if !caps.Workspace.Configuration { // if no configuration request capapbility, return default preferences return s.session.NewUserPreferences(), nil } @@ -448,7 +445,7 @@ func (s *Server) sendResponse(resp *lsproto.ResponseMessage) { } func (s *Server) handleRequestOrNotification(ctx context.Context, req *lsproto.RequestMessage) error { - ctx = lsproto.WithClientCapabilities(ctx, s.clientCapabilities) + ctx = lsproto.WithClientCapabilities(ctx, &s.clientCapabilities) if handler := handlers()[req.Method]; handler != nil { return handler(s, ctx, req) @@ -588,13 +585,11 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ } s.initializeParams = params - s.clientCapabilities = ptrTo(lsproto.FinalizeClientCapabilities(params.Capabilities)) + s.clientCapabilities = finalizeClientCapabilities(params.Capabilities) s.positionEncoding = lsproto.PositionEncodingKindUTF16 - if genCapabilities := s.initializeParams.Capabilities.General; genCapabilities != nil && genCapabilities.PositionEncodings != nil { - if slices.Contains(*genCapabilities.PositionEncodings, lsproto.PositionEncodingKindUTF8) { - s.positionEncoding = lsproto.PositionEncodingKindUTF8 - } + if slices.Contains(s.clientCapabilities.General.PositionEncodings, lsproto.PositionEncodingKindUTF8) { + s.positionEncoding = lsproto.PositionEncodingKindUTF8 } if s.initializeParams.Locale != nil { @@ -695,15 +690,12 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ } func (s *Server) handleInitialized(ctx context.Context, params *lsproto.InitializedParams) error { - if shouldEnableWatch(s.initializeParams) { + if s.clientCapabilities.Workspace.DidChangeWatchedFiles.DynamicRegistration { s.watchEnabled = true } cwd := s.cwd - if s.initializeParams.Capabilities != nil && - s.initializeParams.Capabilities.Workspace != nil && - s.initializeParams.Capabilities.Workspace.WorkspaceFolders != nil && - ptrIsTrue(s.initializeParams.Capabilities.Workspace.WorkspaceFolders) && + if s.clientCapabilities.Workspace.WorkspaceFolders && s.initializeParams.WorkspaceFolders != nil && s.initializeParams.WorkspaceFolders.WorkspaceFolders != nil && len(*s.initializeParams.WorkspaceFolders.WorkspaceFolders) == 1 { @@ -816,11 +808,11 @@ func (s *Server) handleSetTrace(ctx context.Context, params *lsproto.SetTracePar } func (s *Server) handleDocumentDiagnostic(ctx context.Context, ls *ls.LanguageService, params *lsproto.DocumentDiagnosticParams) (lsproto.DocumentDiagnosticResponse, error) { - return ls.ProvideDiagnostics(ctx, params.TextDocument.Uri, getDiagnosticClientCapabilities(s.initializeParams)) + return ls.ProvideDiagnostics(ctx, params.TextDocument.Uri) } func (s *Server) handleHover(ctx context.Context, ls *ls.LanguageService, params *lsproto.HoverParams) (lsproto.HoverResponse, error) { - return ls.ProvideHover(ctx, params.TextDocument.Uri, params.Position, getHoverContentFormat(s.initializeParams)) + return ls.ProvideHover(ctx, params.TextDocument.Uri, params.Position) } func (s *Server) handleSignatureHelp(ctx context.Context, languageService *ls.LanguageService, params *lsproto.SignatureHelpParams) (lsproto.SignatureHelpResponse, error) { @@ -829,17 +821,15 @@ func (s *Server) handleSignatureHelp(ctx context.Context, languageService *ls.La params.TextDocument.Uri, params.Position, params.Context, - s.initializeParams.Capabilities.TextDocument.SignatureHelp, - getSignatureHelpDocumentationFormat(s.initializeParams), ) } func (s *Server) handleDefinition(ctx context.Context, ls *ls.LanguageService, params *lsproto.DefinitionParams) (lsproto.DefinitionResponse, error) { - return ls.ProvideDefinition(ctx, params.TextDocument.Uri, params.Position, getDefinitionClientSupportsLink(s.clientCapabilities)) + return ls.ProvideDefinition(ctx, params.TextDocument.Uri, params.Position) } func (s *Server) handleTypeDefinition(ctx context.Context, ls *ls.LanguageService, params *lsproto.TypeDefinitionParams) (lsproto.TypeDefinitionResponse, error) { - return ls.ProvideTypeDefinition(ctx, params.TextDocument.Uri, params.Position, getTypeDefinitionClientSupportsLink(s.clientCapabilities)) + return ls.ProvideTypeDefinition(ctx, params.TextDocument.Uri, params.Position) } func (s *Server) handleReferences(ctx context.Context, ls *ls.LanguageService, params *lsproto.ReferenceParams) (lsproto.ReferencesResponse, error) { @@ -849,7 +839,7 @@ func (s *Server) handleReferences(ctx context.Context, ls *ls.LanguageService, p func (s *Server) handleImplementations(ctx context.Context, ls *ls.LanguageService, params *lsproto.ImplementationParams) (lsproto.ImplementationResponse, error) { // goToImplementation - return ls.ProvideImplementations(ctx, params, getImplementationClientSupportsLink(s.clientCapabilities)) + return ls.ProvideImplementations(ctx, params) } func (s *Server) handleCompletion(ctx context.Context, languageService *ls.LanguageService, params *lsproto.CompletionParams) (lsproto.CompletionResponse, error) { @@ -858,7 +848,6 @@ func (s *Server) handleCompletion(ctx context.Context, languageService *ls.Langu params.TextDocument.Uri, params.Position, params.Context, - getCompletionClientCapabilities(s.initializeParams), ) } @@ -876,7 +865,6 @@ func (s *Server) handleCompletionItemResolve(ctx context.Context, params *lsprot ctx, params, data, - getCompletionClientCapabilities(s.initializeParams), ) } @@ -916,7 +904,7 @@ func (s *Server) handleWorkspaceSymbol(ctx context.Context, params *lsproto.Work } func (s *Server) handleDocumentSymbol(ctx context.Context, ls *ls.LanguageService, params *lsproto.DocumentSymbolParams) (lsproto.DocumentSymbolResponse, error) { - return ls.ProvideDocumentSymbols(ctx, params.TextDocument.Uri, getDocumentSymbolClientSupportsHierarchical(s.initializeParams)) + return ls.ProvideDocumentSymbols(ctx, params.TextDocument.Uri) } func (s *Server) handleRename(ctx context.Context, ls *ls.LanguageService, params *lsproto.RenameParams) (lsproto.RenameResponse, error) { @@ -935,6 +923,14 @@ func (s *Server) handleCodeAction(ctx context.Context, ls *ls.LanguageService, p return ls.ProvideCodeActions(ctx, params) } +func (s *Server) handleInlayHint( + ctx context.Context, + languageService *ls.LanguageService, + params *lsproto.InlayHintParams, +) (lsproto.InlayHintResponse, error) { + return languageService.ProvideInlayHint(ctx, params) +} + func (s *Server) Log(msg ...any) { fmt.Fprintln(s.stderr, msg...) } @@ -972,105 +968,28 @@ func ptrTo[T any](v T) *T { return &v } -func ptrIsTrue(v *bool) bool { - if v == nil { - return false - } - return *v -} - -func shouldEnableWatch(params *lsproto.InitializeParams) bool { - if params == nil || params.Capabilities == nil || params.Capabilities.Workspace == nil { - return false - } - return params.Capabilities.Workspace.DidChangeWatchedFiles != nil && - ptrIsTrue(params.Capabilities.Workspace.DidChangeWatchedFiles.DynamicRegistration) -} - -func getCompletionClientCapabilities(params *lsproto.InitializeParams) *lsproto.CompletionClientCapabilities { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil { - return nil - } - return params.Capabilities.TextDocument.Completion -} - -func (s *Server) handleInlayHint( - ctx context.Context, - languageService *ls.LanguageService, - params *lsproto.InlayHintParams, -) (lsproto.InlayHintResponse, error) { - return languageService.ProvideInlayHint(ctx, params) -} - -func getDefinitionClientSupportsLink(caps lsproto.FinalizedClientCapabilities) bool { - return caps.TextDocument.Definition.LinkSupport -} - -func getTypeDefinitionClientSupportsLink(caps lsproto.FinalizedClientCapabilities) bool { - return caps.TextDocument.TypeDefinition.LinkSupport -} - -func getImplementationClientSupportsLink(caps lsproto.FinalizedClientCapabilities) bool { - return caps.TextDocument.Implementation.LinkSupport -} - -func getDocumentSymbolClientSupportsHierarchical(params *lsproto.InitializeParams) bool { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil || - params.Capabilities.TextDocument.DocumentSymbol == nil { - return false - } - return ptrIsTrue(params.Capabilities.TextDocument.DocumentSymbol.HierarchicalDocumentSymbolSupport) -} - -func getHoverContentFormat(params *lsproto.InitializeParams) lsproto.MarkupKind { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil || params.Capabilities.TextDocument.Hover == nil || params.Capabilities.TextDocument.Hover.ContentFormat == nil { - // Default to plaintext if no preference specified - return lsproto.MarkupKindPlainText - } - formats := *params.Capabilities.TextDocument.Hover.ContentFormat - if len(formats) == 0 { - return lsproto.MarkupKindPlainText - } - // Return the first (most preferred) format - return formats[0] -} - -func getSignatureHelpDocumentationFormat(params *lsproto.InitializeParams) lsproto.MarkupKind { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil || params.Capabilities.TextDocument.SignatureHelp == nil || - params.Capabilities.TextDocument.SignatureHelp.SignatureInformation == nil || - params.Capabilities.TextDocument.SignatureHelp.SignatureInformation.DocumentationFormat == nil { - // Default to plaintext if no preference specified - return lsproto.MarkupKindPlainText - } - formats := *params.Capabilities.TextDocument.SignatureHelp.SignatureInformation.DocumentationFormat - if len(formats) == 0 { - return lsproto.MarkupKindPlainText - } - // Return the first (most preferred) format - return formats[0] -} - -func getDiagnosticClientCapabilities(params *lsproto.InitializeParams) *lsproto.DiagnosticClientCapabilities { - if params == nil || params.Capabilities == nil || params.Capabilities.TextDocument == nil { - return nil - } - - var caps lsproto.DiagnosticClientCapabilities - if params.Capabilities.TextDocument.Diagnostic != nil { - caps = *params.Capabilities.TextDocument.Diagnostic - } +func finalizeClientCapabilities(caps *lsproto.ClientCapabilities) lsproto.FinalizedClientCapabilities { + finalized := lsproto.FinalizeClientCapabilities(caps) // Some clients claim that push and pull diagnostics have different capabilities, // including vscode-languageclient v9. Work around this by defaulting any missing // pull diagnostic caps with the pull diagnostic equivalents. // // TODO: remove when we upgrade to vscode-languageclient v10, which fixes this issue. - if publish := params.Capabilities.TextDocument.PublishDiagnostics; publish != nil { - caps.RelatedInformation = core.Coalesce(caps.RelatedInformation, publish.RelatedInformation) - caps.TagSupport = core.Coalesce(caps.TagSupport, publish.TagSupport) - caps.CodeDescriptionSupport = core.Coalesce(caps.CodeDescriptionSupport, publish.CodeDescriptionSupport) - caps.DataSupport = core.Coalesce(caps.DataSupport, publish.DataSupport) + publish := finalized.TextDocument.PublishDiagnostics + diagnostic := &finalized.TextDocument.Diagnostic + if !diagnostic.RelatedInformation && publish.RelatedInformation { + diagnostic.RelatedInformation = true + } + if !diagnostic.CodeDescriptionSupport && publish.CodeDescriptionSupport { + diagnostic.CodeDescriptionSupport = true + } + if !diagnostic.DataSupport && publish.DataSupport { + diagnostic.DataSupport = true + } + if len(diagnostic.TagSupport.ValueSet) == 0 && len(publish.TagSupport.ValueSet) > 0 { + diagnostic.TagSupport.ValueSet = publish.TagSupport.ValueSet } - return &caps + return finalized } diff --git a/internal/project/untitled_test.go b/internal/project/untitled_test.go index 8eb0b93054..0291394040 100644 --- a/internal/project/untitled_test.go +++ b/internal/project/untitled_test.go @@ -87,7 +87,7 @@ x++;` assert.Assert(t, len(refs) == 3, "Expected 3 references, got %d", len(refs)) // Also test definition using ProvideDefinition - definition, err := languageService.ProvideDefinition(ctx, uri, lspPosition, false) + definition, err := languageService.ProvideDefinition(ctx, uri, lspPosition) assert.NilError(t, err) if definition.Locations != nil { t.Logf("Definition found: %d locations", len(*definition.Locations)) From 4f6af53b17eb019ff5045056e9b758a3c8bbba63 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 13:37:05 -0800 Subject: [PATCH 5/8] Rename type --- internal/lsp/lsproto/_generate/generate.mts | 40 +- internal/lsp/lsproto/lsp.go | 8 +- internal/lsp/lsproto/lsp_generated.go | 986 ++++++++++---------- internal/lsp/server.go | 14 +- 4 files changed, 524 insertions(+), 524 deletions(-) diff --git a/internal/lsp/lsproto/_generate/generate.mts b/internal/lsp/lsproto/_generate/generate.mts index dfdf26c95e..d690782e0b 100644 --- a/internal/lsp/lsproto/_generate/generate.mts +++ b/internal/lsp/lsproto/_generate/generate.mts @@ -472,18 +472,18 @@ function generateCode() { parts.push(s + "\n"); } - function generateFinalizedStruct(structure: Structure, indent: string = "\t"): string[] { + function generateResolvedStruct(structure: Structure, indent: string = "\t"): string[] { const lines: string[] = []; for (const prop of structure.properties) { const type = resolveType(prop.type); - // For reference types that are structures, use a named finalized type + // For reference types that are structures, use a named resolved type if (prop.type.kind === "reference") { const refStructure = model.structures.find(s => s.name === type.name); if (refStructure) { - // Use a named type for the finalized version - lines.push(`${indent}${titleCase(prop.name)} Finalized${type.name}`); + // Use a named type for the resolved version + lines.push(`${indent}${titleCase(prop.name)} Resolved${type.name}`); continue; } } @@ -496,7 +496,7 @@ function generateCode() { return lines; } - function generateFinalizeConversion(structure: Structure, varName: string, indent: string): string[] { + function generateResolveConversion(structure: Structure, varName: string, indent: string): string[] { const lines: string[] = []; for (const prop of structure.properties) { @@ -504,12 +504,12 @@ function generateCode() { const fieldName = titleCase(prop.name); const accessPath = `${varName}.${fieldName}`; - // For reference types that are structures, call the finalize function + // For reference types that are structures, call the resolve function if (prop.type.kind === "reference") { const refStructure = model.structures.find(s => s.name === type.name); if (refStructure) { // Use lowercase (unexported) function name for helper functions - lines.push(`${indent}${fieldName}: finalize${type.name}(${accessPath}),`); + lines.push(`${indent}${fieldName}: resolve${type.name}(${accessPath}),`); continue; } } @@ -547,15 +547,15 @@ function generateCode() { return deps; } - function generateFinalizedTypeAndHelper(structure: Structure, isMain: boolean = false): string[] { + function generateResolvedTypeAndHelper(structure: Structure, isMain: boolean = false): string[] { const lines: string[] = []; - const typeName = `Finalized${structure.name}`; + const typeName = `Resolved${structure.name}`; // Main function is exported, helpers are unexported - const funcName = isMain ? `Finalize${structure.name}` : `finalize${structure.name}`; + const funcName = isMain ? `Resolve${structure.name}` : `resolve${structure.name}`; - // Generate the finalized type + // Generate the resolved type lines.push(`type ${typeName} struct {`); - lines.push(...generateFinalizedStruct(structure, "\t")); + lines.push(...generateResolvedStruct(structure, "\t")); lines.push(`}`); lines.push(``); @@ -565,7 +565,7 @@ function generateCode() { lines.push(`\t\treturn ${typeName}{}`); lines.push(`\t}`); lines.push(`\treturn ${typeName}{`); - lines.push(...generateFinalizeConversion(structure, "v", "\t\t")); + lines.push(...generateResolveConversion(structure, "v", "\t\t")); lines.push(`\t}`); lines.push(`}`); lines.push(``); @@ -979,7 +979,7 @@ function generateCode() { writeLine(""); } - // Generate finalized capabilities + // Generate resolved capabilities const clientCapsStructure = model.structures.find(s => s.name === "ClientCapabilities"); if (clientCapsStructure) { writeLine("// Helper function for dereferencing pointers with zero value fallback"); @@ -992,22 +992,22 @@ function generateCode() { writeLine("}"); writeLine(""); - // Collect all dependent structures and generate their finalized types + // Collect all dependent structures and generate their resolved types const deps = collectStructureDependencies(clientCapsStructure); const uniqueDeps = Array.from(new Map(deps.map(d => [d.name, d])).values()); for (const dep of uniqueDeps) { - const depLines = generateFinalizedTypeAndHelper(dep, false); + const depLines = generateResolvedTypeAndHelper(dep, false); for (const line of depLines) { writeLine(line); } } - // Generate the main FinalizedClientCapabilities type and function - writeLine("// FinalizedClientCapabilities is a version of ClientCapabilities where all nested"); + // Generate the main ResolvedClientCapabilities type and function + writeLine("// ResolvedClientCapabilities is a version of ClientCapabilities where all nested"); writeLine("// fields are values (not pointers), making it easier to access deeply nested capabilities."); - writeLine("// Use FinalizeClientCapabilities to convert from ClientCapabilities."); - const mainLines = generateFinalizedTypeAndHelper(clientCapsStructure, true); + writeLine("// Use ResolveClientCapabilities to convert from ClientCapabilities."); + const mainLines = generateResolvedTypeAndHelper(clientCapsStructure, true); for (const line of mainLines) { writeLine(line); } diff --git a/internal/lsp/lsproto/lsp.go b/internal/lsp/lsproto/lsp.go index c4b4f91697..cc27437593 100644 --- a/internal/lsp/lsproto/lsp.go +++ b/internal/lsp/lsproto/lsp.go @@ -153,15 +153,15 @@ func (Null) MarshalJSONTo(enc *jsontext.Encoder) error { type clientCapabilitiesKey struct{} -func WithClientCapabilities(ctx context.Context, caps *FinalizedClientCapabilities) context.Context { +func WithClientCapabilities(ctx context.Context, caps *ResolvedClientCapabilities) context.Context { return context.WithValue(ctx, clientCapabilitiesKey{}, caps) } -func GetClientCapabilities(ctx context.Context) *FinalizedClientCapabilities { - if caps, _ := ctx.Value(clientCapabilitiesKey{}).(*FinalizedClientCapabilities); caps != nil { +func GetClientCapabilities(ctx context.Context) *ResolvedClientCapabilities { + if caps, _ := ctx.Value(clientCapabilitiesKey{}).(*ResolvedClientCapabilities); caps != nil { return caps } - return &FinalizedClientCapabilities{} + return &ResolvedClientCapabilities{} } // PreferredMarkupKind returns the first (most preferred) markup kind from the given formats, diff --git a/internal/lsp/lsproto/lsp_generated.go b/internal/lsp/lsproto/lsp_generated.go index dcd5e4a533..f7589a45cb 100644 --- a/internal/lsp/lsproto/lsp_generated.go +++ b/internal/lsp/lsproto/lsp_generated.go @@ -25735,170 +25735,170 @@ func derefOr[T any](v *T) T { return zero } -type FinalizedChangeAnnotationsSupportOptions struct { +type ResolvedChangeAnnotationsSupportOptions struct { GroupsOnLabel bool } -func finalizeChangeAnnotationsSupportOptions(v *ChangeAnnotationsSupportOptions) FinalizedChangeAnnotationsSupportOptions { +func resolveChangeAnnotationsSupportOptions(v *ChangeAnnotationsSupportOptions) ResolvedChangeAnnotationsSupportOptions { if v == nil { - return FinalizedChangeAnnotationsSupportOptions{} + return ResolvedChangeAnnotationsSupportOptions{} } - return FinalizedChangeAnnotationsSupportOptions{ + return ResolvedChangeAnnotationsSupportOptions{ GroupsOnLabel: derefOr(v.GroupsOnLabel), } } -type FinalizedWorkspaceEditClientCapabilities struct { +type ResolvedWorkspaceEditClientCapabilities struct { DocumentChanges bool ResourceOperations []ResourceOperationKind FailureHandling FailureHandlingKind NormalizesLineEndings bool - ChangeAnnotationSupport FinalizedChangeAnnotationsSupportOptions + ChangeAnnotationSupport ResolvedChangeAnnotationsSupportOptions MetadataSupport bool SnippetEditSupport bool } -func finalizeWorkspaceEditClientCapabilities(v *WorkspaceEditClientCapabilities) FinalizedWorkspaceEditClientCapabilities { +func resolveWorkspaceEditClientCapabilities(v *WorkspaceEditClientCapabilities) ResolvedWorkspaceEditClientCapabilities { if v == nil { - return FinalizedWorkspaceEditClientCapabilities{} + return ResolvedWorkspaceEditClientCapabilities{} } - return FinalizedWorkspaceEditClientCapabilities{ + return ResolvedWorkspaceEditClientCapabilities{ DocumentChanges: derefOr(v.DocumentChanges), ResourceOperations: derefOr(v.ResourceOperations), FailureHandling: derefOr(v.FailureHandling), NormalizesLineEndings: derefOr(v.NormalizesLineEndings), - ChangeAnnotationSupport: finalizeChangeAnnotationsSupportOptions(v.ChangeAnnotationSupport), + ChangeAnnotationSupport: resolveChangeAnnotationsSupportOptions(v.ChangeAnnotationSupport), MetadataSupport: derefOr(v.MetadataSupport), SnippetEditSupport: derefOr(v.SnippetEditSupport), } } -type FinalizedDidChangeConfigurationClientCapabilities struct { +type ResolvedDidChangeConfigurationClientCapabilities struct { DynamicRegistration bool } -func finalizeDidChangeConfigurationClientCapabilities(v *DidChangeConfigurationClientCapabilities) FinalizedDidChangeConfigurationClientCapabilities { +func resolveDidChangeConfigurationClientCapabilities(v *DidChangeConfigurationClientCapabilities) ResolvedDidChangeConfigurationClientCapabilities { if v == nil { - return FinalizedDidChangeConfigurationClientCapabilities{} + return ResolvedDidChangeConfigurationClientCapabilities{} } - return FinalizedDidChangeConfigurationClientCapabilities{ + return ResolvedDidChangeConfigurationClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedDidChangeWatchedFilesClientCapabilities struct { +type ResolvedDidChangeWatchedFilesClientCapabilities struct { DynamicRegistration bool RelativePatternSupport bool } -func finalizeDidChangeWatchedFilesClientCapabilities(v *DidChangeWatchedFilesClientCapabilities) FinalizedDidChangeWatchedFilesClientCapabilities { +func resolveDidChangeWatchedFilesClientCapabilities(v *DidChangeWatchedFilesClientCapabilities) ResolvedDidChangeWatchedFilesClientCapabilities { if v == nil { - return FinalizedDidChangeWatchedFilesClientCapabilities{} + return ResolvedDidChangeWatchedFilesClientCapabilities{} } - return FinalizedDidChangeWatchedFilesClientCapabilities{ + return ResolvedDidChangeWatchedFilesClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), RelativePatternSupport: derefOr(v.RelativePatternSupport), } } -type FinalizedClientSymbolKindOptions struct { +type ResolvedClientSymbolKindOptions struct { ValueSet []SymbolKind } -func finalizeClientSymbolKindOptions(v *ClientSymbolKindOptions) FinalizedClientSymbolKindOptions { +func resolveClientSymbolKindOptions(v *ClientSymbolKindOptions) ResolvedClientSymbolKindOptions { if v == nil { - return FinalizedClientSymbolKindOptions{} + return ResolvedClientSymbolKindOptions{} } - return FinalizedClientSymbolKindOptions{ + return ResolvedClientSymbolKindOptions{ ValueSet: derefOr(v.ValueSet), } } -type FinalizedClientSymbolTagOptions struct { +type ResolvedClientSymbolTagOptions struct { ValueSet []SymbolTag } -func finalizeClientSymbolTagOptions(v *ClientSymbolTagOptions) FinalizedClientSymbolTagOptions { +func resolveClientSymbolTagOptions(v *ClientSymbolTagOptions) ResolvedClientSymbolTagOptions { if v == nil { - return FinalizedClientSymbolTagOptions{} + return ResolvedClientSymbolTagOptions{} } - return FinalizedClientSymbolTagOptions{ + return ResolvedClientSymbolTagOptions{ ValueSet: v.ValueSet, } } -type FinalizedClientSymbolResolveOptions struct { +type ResolvedClientSymbolResolveOptions struct { Properties []string } -func finalizeClientSymbolResolveOptions(v *ClientSymbolResolveOptions) FinalizedClientSymbolResolveOptions { +func resolveClientSymbolResolveOptions(v *ClientSymbolResolveOptions) ResolvedClientSymbolResolveOptions { if v == nil { - return FinalizedClientSymbolResolveOptions{} + return ResolvedClientSymbolResolveOptions{} } - return FinalizedClientSymbolResolveOptions{ + return ResolvedClientSymbolResolveOptions{ Properties: v.Properties, } } -type FinalizedWorkspaceSymbolClientCapabilities struct { +type ResolvedWorkspaceSymbolClientCapabilities struct { DynamicRegistration bool - SymbolKind FinalizedClientSymbolKindOptions - TagSupport FinalizedClientSymbolTagOptions - ResolveSupport FinalizedClientSymbolResolveOptions + SymbolKind ResolvedClientSymbolKindOptions + TagSupport ResolvedClientSymbolTagOptions + ResolveSupport ResolvedClientSymbolResolveOptions } -func finalizeWorkspaceSymbolClientCapabilities(v *WorkspaceSymbolClientCapabilities) FinalizedWorkspaceSymbolClientCapabilities { +func resolveWorkspaceSymbolClientCapabilities(v *WorkspaceSymbolClientCapabilities) ResolvedWorkspaceSymbolClientCapabilities { if v == nil { - return FinalizedWorkspaceSymbolClientCapabilities{} + return ResolvedWorkspaceSymbolClientCapabilities{} } - return FinalizedWorkspaceSymbolClientCapabilities{ + return ResolvedWorkspaceSymbolClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - SymbolKind: finalizeClientSymbolKindOptions(v.SymbolKind), - TagSupport: finalizeClientSymbolTagOptions(v.TagSupport), - ResolveSupport: finalizeClientSymbolResolveOptions(v.ResolveSupport), + SymbolKind: resolveClientSymbolKindOptions(v.SymbolKind), + TagSupport: resolveClientSymbolTagOptions(v.TagSupport), + ResolveSupport: resolveClientSymbolResolveOptions(v.ResolveSupport), } } -type FinalizedExecuteCommandClientCapabilities struct { +type ResolvedExecuteCommandClientCapabilities struct { DynamicRegistration bool } -func finalizeExecuteCommandClientCapabilities(v *ExecuteCommandClientCapabilities) FinalizedExecuteCommandClientCapabilities { +func resolveExecuteCommandClientCapabilities(v *ExecuteCommandClientCapabilities) ResolvedExecuteCommandClientCapabilities { if v == nil { - return FinalizedExecuteCommandClientCapabilities{} + return ResolvedExecuteCommandClientCapabilities{} } - return FinalizedExecuteCommandClientCapabilities{ + return ResolvedExecuteCommandClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedSemanticTokensWorkspaceClientCapabilities struct { +type ResolvedSemanticTokensWorkspaceClientCapabilities struct { RefreshSupport bool } -func finalizeSemanticTokensWorkspaceClientCapabilities(v *SemanticTokensWorkspaceClientCapabilities) FinalizedSemanticTokensWorkspaceClientCapabilities { +func resolveSemanticTokensWorkspaceClientCapabilities(v *SemanticTokensWorkspaceClientCapabilities) ResolvedSemanticTokensWorkspaceClientCapabilities { if v == nil { - return FinalizedSemanticTokensWorkspaceClientCapabilities{} + return ResolvedSemanticTokensWorkspaceClientCapabilities{} } - return FinalizedSemanticTokensWorkspaceClientCapabilities{ + return ResolvedSemanticTokensWorkspaceClientCapabilities{ RefreshSupport: derefOr(v.RefreshSupport), } } -type FinalizedCodeLensWorkspaceClientCapabilities struct { +type ResolvedCodeLensWorkspaceClientCapabilities struct { RefreshSupport bool } -func finalizeCodeLensWorkspaceClientCapabilities(v *CodeLensWorkspaceClientCapabilities) FinalizedCodeLensWorkspaceClientCapabilities { +func resolveCodeLensWorkspaceClientCapabilities(v *CodeLensWorkspaceClientCapabilities) ResolvedCodeLensWorkspaceClientCapabilities { if v == nil { - return FinalizedCodeLensWorkspaceClientCapabilities{} + return ResolvedCodeLensWorkspaceClientCapabilities{} } - return FinalizedCodeLensWorkspaceClientCapabilities{ + return ResolvedCodeLensWorkspaceClientCapabilities{ RefreshSupport: derefOr(v.RefreshSupport), } } -type FinalizedFileOperationClientCapabilities struct { +type ResolvedFileOperationClientCapabilities struct { DynamicRegistration bool DidCreate bool WillCreate bool @@ -25908,11 +25908,11 @@ type FinalizedFileOperationClientCapabilities struct { WillDelete bool } -func finalizeFileOperationClientCapabilities(v *FileOperationClientCapabilities) FinalizedFileOperationClientCapabilities { +func resolveFileOperationClientCapabilities(v *FileOperationClientCapabilities) ResolvedFileOperationClientCapabilities { if v == nil { - return FinalizedFileOperationClientCapabilities{} + return ResolvedFileOperationClientCapabilities{} } - return FinalizedFileOperationClientCapabilities{ + return ResolvedFileOperationClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), DidCreate: derefOr(v.DidCreate), WillCreate: derefOr(v.WillCreate), @@ -25923,126 +25923,126 @@ func finalizeFileOperationClientCapabilities(v *FileOperationClientCapabilities) } } -type FinalizedInlineValueWorkspaceClientCapabilities struct { +type ResolvedInlineValueWorkspaceClientCapabilities struct { RefreshSupport bool } -func finalizeInlineValueWorkspaceClientCapabilities(v *InlineValueWorkspaceClientCapabilities) FinalizedInlineValueWorkspaceClientCapabilities { +func resolveInlineValueWorkspaceClientCapabilities(v *InlineValueWorkspaceClientCapabilities) ResolvedInlineValueWorkspaceClientCapabilities { if v == nil { - return FinalizedInlineValueWorkspaceClientCapabilities{} + return ResolvedInlineValueWorkspaceClientCapabilities{} } - return FinalizedInlineValueWorkspaceClientCapabilities{ + return ResolvedInlineValueWorkspaceClientCapabilities{ RefreshSupport: derefOr(v.RefreshSupport), } } -type FinalizedInlayHintWorkspaceClientCapabilities struct { +type ResolvedInlayHintWorkspaceClientCapabilities struct { RefreshSupport bool } -func finalizeInlayHintWorkspaceClientCapabilities(v *InlayHintWorkspaceClientCapabilities) FinalizedInlayHintWorkspaceClientCapabilities { +func resolveInlayHintWorkspaceClientCapabilities(v *InlayHintWorkspaceClientCapabilities) ResolvedInlayHintWorkspaceClientCapabilities { if v == nil { - return FinalizedInlayHintWorkspaceClientCapabilities{} + return ResolvedInlayHintWorkspaceClientCapabilities{} } - return FinalizedInlayHintWorkspaceClientCapabilities{ + return ResolvedInlayHintWorkspaceClientCapabilities{ RefreshSupport: derefOr(v.RefreshSupport), } } -type FinalizedDiagnosticWorkspaceClientCapabilities struct { +type ResolvedDiagnosticWorkspaceClientCapabilities struct { RefreshSupport bool } -func finalizeDiagnosticWorkspaceClientCapabilities(v *DiagnosticWorkspaceClientCapabilities) FinalizedDiagnosticWorkspaceClientCapabilities { +func resolveDiagnosticWorkspaceClientCapabilities(v *DiagnosticWorkspaceClientCapabilities) ResolvedDiagnosticWorkspaceClientCapabilities { if v == nil { - return FinalizedDiagnosticWorkspaceClientCapabilities{} + return ResolvedDiagnosticWorkspaceClientCapabilities{} } - return FinalizedDiagnosticWorkspaceClientCapabilities{ + return ResolvedDiagnosticWorkspaceClientCapabilities{ RefreshSupport: derefOr(v.RefreshSupport), } } -type FinalizedFoldingRangeWorkspaceClientCapabilities struct { +type ResolvedFoldingRangeWorkspaceClientCapabilities struct { RefreshSupport bool } -func finalizeFoldingRangeWorkspaceClientCapabilities(v *FoldingRangeWorkspaceClientCapabilities) FinalizedFoldingRangeWorkspaceClientCapabilities { +func resolveFoldingRangeWorkspaceClientCapabilities(v *FoldingRangeWorkspaceClientCapabilities) ResolvedFoldingRangeWorkspaceClientCapabilities { if v == nil { - return FinalizedFoldingRangeWorkspaceClientCapabilities{} + return ResolvedFoldingRangeWorkspaceClientCapabilities{} } - return FinalizedFoldingRangeWorkspaceClientCapabilities{ + return ResolvedFoldingRangeWorkspaceClientCapabilities{ RefreshSupport: derefOr(v.RefreshSupport), } } -type FinalizedTextDocumentContentClientCapabilities struct { +type ResolvedTextDocumentContentClientCapabilities struct { DynamicRegistration bool } -func finalizeTextDocumentContentClientCapabilities(v *TextDocumentContentClientCapabilities) FinalizedTextDocumentContentClientCapabilities { +func resolveTextDocumentContentClientCapabilities(v *TextDocumentContentClientCapabilities) ResolvedTextDocumentContentClientCapabilities { if v == nil { - return FinalizedTextDocumentContentClientCapabilities{} + return ResolvedTextDocumentContentClientCapabilities{} } - return FinalizedTextDocumentContentClientCapabilities{ + return ResolvedTextDocumentContentClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedWorkspaceClientCapabilities struct { +type ResolvedWorkspaceClientCapabilities struct { ApplyEdit bool - WorkspaceEdit FinalizedWorkspaceEditClientCapabilities - DidChangeConfiguration FinalizedDidChangeConfigurationClientCapabilities - DidChangeWatchedFiles FinalizedDidChangeWatchedFilesClientCapabilities - Symbol FinalizedWorkspaceSymbolClientCapabilities - ExecuteCommand FinalizedExecuteCommandClientCapabilities + WorkspaceEdit ResolvedWorkspaceEditClientCapabilities + DidChangeConfiguration ResolvedDidChangeConfigurationClientCapabilities + DidChangeWatchedFiles ResolvedDidChangeWatchedFilesClientCapabilities + Symbol ResolvedWorkspaceSymbolClientCapabilities + ExecuteCommand ResolvedExecuteCommandClientCapabilities WorkspaceFolders bool Configuration bool - SemanticTokens FinalizedSemanticTokensWorkspaceClientCapabilities - CodeLens FinalizedCodeLensWorkspaceClientCapabilities - FileOperations FinalizedFileOperationClientCapabilities - InlineValue FinalizedInlineValueWorkspaceClientCapabilities - InlayHint FinalizedInlayHintWorkspaceClientCapabilities - Diagnostics FinalizedDiagnosticWorkspaceClientCapabilities - FoldingRange FinalizedFoldingRangeWorkspaceClientCapabilities - TextDocumentContent FinalizedTextDocumentContentClientCapabilities + SemanticTokens ResolvedSemanticTokensWorkspaceClientCapabilities + CodeLens ResolvedCodeLensWorkspaceClientCapabilities + FileOperations ResolvedFileOperationClientCapabilities + InlineValue ResolvedInlineValueWorkspaceClientCapabilities + InlayHint ResolvedInlayHintWorkspaceClientCapabilities + Diagnostics ResolvedDiagnosticWorkspaceClientCapabilities + FoldingRange ResolvedFoldingRangeWorkspaceClientCapabilities + TextDocumentContent ResolvedTextDocumentContentClientCapabilities } -func finalizeWorkspaceClientCapabilities(v *WorkspaceClientCapabilities) FinalizedWorkspaceClientCapabilities { +func resolveWorkspaceClientCapabilities(v *WorkspaceClientCapabilities) ResolvedWorkspaceClientCapabilities { if v == nil { - return FinalizedWorkspaceClientCapabilities{} + return ResolvedWorkspaceClientCapabilities{} } - return FinalizedWorkspaceClientCapabilities{ + return ResolvedWorkspaceClientCapabilities{ ApplyEdit: derefOr(v.ApplyEdit), - WorkspaceEdit: finalizeWorkspaceEditClientCapabilities(v.WorkspaceEdit), - DidChangeConfiguration: finalizeDidChangeConfigurationClientCapabilities(v.DidChangeConfiguration), - DidChangeWatchedFiles: finalizeDidChangeWatchedFilesClientCapabilities(v.DidChangeWatchedFiles), - Symbol: finalizeWorkspaceSymbolClientCapabilities(v.Symbol), - ExecuteCommand: finalizeExecuteCommandClientCapabilities(v.ExecuteCommand), + WorkspaceEdit: resolveWorkspaceEditClientCapabilities(v.WorkspaceEdit), + DidChangeConfiguration: resolveDidChangeConfigurationClientCapabilities(v.DidChangeConfiguration), + DidChangeWatchedFiles: resolveDidChangeWatchedFilesClientCapabilities(v.DidChangeWatchedFiles), + Symbol: resolveWorkspaceSymbolClientCapabilities(v.Symbol), + ExecuteCommand: resolveExecuteCommandClientCapabilities(v.ExecuteCommand), WorkspaceFolders: derefOr(v.WorkspaceFolders), Configuration: derefOr(v.Configuration), - SemanticTokens: finalizeSemanticTokensWorkspaceClientCapabilities(v.SemanticTokens), - CodeLens: finalizeCodeLensWorkspaceClientCapabilities(v.CodeLens), - FileOperations: finalizeFileOperationClientCapabilities(v.FileOperations), - InlineValue: finalizeInlineValueWorkspaceClientCapabilities(v.InlineValue), - InlayHint: finalizeInlayHintWorkspaceClientCapabilities(v.InlayHint), - Diagnostics: finalizeDiagnosticWorkspaceClientCapabilities(v.Diagnostics), - FoldingRange: finalizeFoldingRangeWorkspaceClientCapabilities(v.FoldingRange), - TextDocumentContent: finalizeTextDocumentContentClientCapabilities(v.TextDocumentContent), + SemanticTokens: resolveSemanticTokensWorkspaceClientCapabilities(v.SemanticTokens), + CodeLens: resolveCodeLensWorkspaceClientCapabilities(v.CodeLens), + FileOperations: resolveFileOperationClientCapabilities(v.FileOperations), + InlineValue: resolveInlineValueWorkspaceClientCapabilities(v.InlineValue), + InlayHint: resolveInlayHintWorkspaceClientCapabilities(v.InlayHint), + Diagnostics: resolveDiagnosticWorkspaceClientCapabilities(v.Diagnostics), + FoldingRange: resolveFoldingRangeWorkspaceClientCapabilities(v.FoldingRange), + TextDocumentContent: resolveTextDocumentContentClientCapabilities(v.TextDocumentContent), } } -type FinalizedTextDocumentSyncClientCapabilities struct { +type ResolvedTextDocumentSyncClientCapabilities struct { DynamicRegistration bool WillSave bool WillSaveWaitUntil bool DidSave bool } -func finalizeTextDocumentSyncClientCapabilities(v *TextDocumentSyncClientCapabilities) FinalizedTextDocumentSyncClientCapabilities { +func resolveTextDocumentSyncClientCapabilities(v *TextDocumentSyncClientCapabilities) ResolvedTextDocumentSyncClientCapabilities { if v == nil { - return FinalizedTextDocumentSyncClientCapabilities{} + return ResolvedTextDocumentSyncClientCapabilities{} } - return FinalizedTextDocumentSyncClientCapabilities{ + return ResolvedTextDocumentSyncClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), WillSave: derefOr(v.WillSave), WillSaveWaitUntil: derefOr(v.WillSaveWaitUntil), @@ -26050,501 +26050,501 @@ func finalizeTextDocumentSyncClientCapabilities(v *TextDocumentSyncClientCapabil } } -type FinalizedTextDocumentFilterClientCapabilities struct { +type ResolvedTextDocumentFilterClientCapabilities struct { RelativePatternSupport bool } -func finalizeTextDocumentFilterClientCapabilities(v *TextDocumentFilterClientCapabilities) FinalizedTextDocumentFilterClientCapabilities { +func resolveTextDocumentFilterClientCapabilities(v *TextDocumentFilterClientCapabilities) ResolvedTextDocumentFilterClientCapabilities { if v == nil { - return FinalizedTextDocumentFilterClientCapabilities{} + return ResolvedTextDocumentFilterClientCapabilities{} } - return FinalizedTextDocumentFilterClientCapabilities{ + return ResolvedTextDocumentFilterClientCapabilities{ RelativePatternSupport: derefOr(v.RelativePatternSupport), } } -type FinalizedCompletionItemTagOptions struct { +type ResolvedCompletionItemTagOptions struct { ValueSet []CompletionItemTag } -func finalizeCompletionItemTagOptions(v *CompletionItemTagOptions) FinalizedCompletionItemTagOptions { +func resolveCompletionItemTagOptions(v *CompletionItemTagOptions) ResolvedCompletionItemTagOptions { if v == nil { - return FinalizedCompletionItemTagOptions{} + return ResolvedCompletionItemTagOptions{} } - return FinalizedCompletionItemTagOptions{ + return ResolvedCompletionItemTagOptions{ ValueSet: v.ValueSet, } } -type FinalizedClientCompletionItemResolveOptions struct { +type ResolvedClientCompletionItemResolveOptions struct { Properties []string } -func finalizeClientCompletionItemResolveOptions(v *ClientCompletionItemResolveOptions) FinalizedClientCompletionItemResolveOptions { +func resolveClientCompletionItemResolveOptions(v *ClientCompletionItemResolveOptions) ResolvedClientCompletionItemResolveOptions { if v == nil { - return FinalizedClientCompletionItemResolveOptions{} + return ResolvedClientCompletionItemResolveOptions{} } - return FinalizedClientCompletionItemResolveOptions{ + return ResolvedClientCompletionItemResolveOptions{ Properties: v.Properties, } } -type FinalizedClientCompletionItemInsertTextModeOptions struct { +type ResolvedClientCompletionItemInsertTextModeOptions struct { ValueSet []InsertTextMode } -func finalizeClientCompletionItemInsertTextModeOptions(v *ClientCompletionItemInsertTextModeOptions) FinalizedClientCompletionItemInsertTextModeOptions { +func resolveClientCompletionItemInsertTextModeOptions(v *ClientCompletionItemInsertTextModeOptions) ResolvedClientCompletionItemInsertTextModeOptions { if v == nil { - return FinalizedClientCompletionItemInsertTextModeOptions{} + return ResolvedClientCompletionItemInsertTextModeOptions{} } - return FinalizedClientCompletionItemInsertTextModeOptions{ + return ResolvedClientCompletionItemInsertTextModeOptions{ ValueSet: v.ValueSet, } } -type FinalizedClientCompletionItemOptions struct { +type ResolvedClientCompletionItemOptions struct { SnippetSupport bool CommitCharactersSupport bool DocumentationFormat []MarkupKind DeprecatedSupport bool PreselectSupport bool - TagSupport FinalizedCompletionItemTagOptions + TagSupport ResolvedCompletionItemTagOptions InsertReplaceSupport bool - ResolveSupport FinalizedClientCompletionItemResolveOptions - InsertTextModeSupport FinalizedClientCompletionItemInsertTextModeOptions + ResolveSupport ResolvedClientCompletionItemResolveOptions + InsertTextModeSupport ResolvedClientCompletionItemInsertTextModeOptions LabelDetailsSupport bool } -func finalizeClientCompletionItemOptions(v *ClientCompletionItemOptions) FinalizedClientCompletionItemOptions { +func resolveClientCompletionItemOptions(v *ClientCompletionItemOptions) ResolvedClientCompletionItemOptions { if v == nil { - return FinalizedClientCompletionItemOptions{} + return ResolvedClientCompletionItemOptions{} } - return FinalizedClientCompletionItemOptions{ + return ResolvedClientCompletionItemOptions{ SnippetSupport: derefOr(v.SnippetSupport), CommitCharactersSupport: derefOr(v.CommitCharactersSupport), DocumentationFormat: derefOr(v.DocumentationFormat), DeprecatedSupport: derefOr(v.DeprecatedSupport), PreselectSupport: derefOr(v.PreselectSupport), - TagSupport: finalizeCompletionItemTagOptions(v.TagSupport), + TagSupport: resolveCompletionItemTagOptions(v.TagSupport), InsertReplaceSupport: derefOr(v.InsertReplaceSupport), - ResolveSupport: finalizeClientCompletionItemResolveOptions(v.ResolveSupport), - InsertTextModeSupport: finalizeClientCompletionItemInsertTextModeOptions(v.InsertTextModeSupport), + ResolveSupport: resolveClientCompletionItemResolveOptions(v.ResolveSupport), + InsertTextModeSupport: resolveClientCompletionItemInsertTextModeOptions(v.InsertTextModeSupport), LabelDetailsSupport: derefOr(v.LabelDetailsSupport), } } -type FinalizedClientCompletionItemOptionsKind struct { +type ResolvedClientCompletionItemOptionsKind struct { ValueSet []CompletionItemKind } -func finalizeClientCompletionItemOptionsKind(v *ClientCompletionItemOptionsKind) FinalizedClientCompletionItemOptionsKind { +func resolveClientCompletionItemOptionsKind(v *ClientCompletionItemOptionsKind) ResolvedClientCompletionItemOptionsKind { if v == nil { - return FinalizedClientCompletionItemOptionsKind{} + return ResolvedClientCompletionItemOptionsKind{} } - return FinalizedClientCompletionItemOptionsKind{ + return ResolvedClientCompletionItemOptionsKind{ ValueSet: derefOr(v.ValueSet), } } -type FinalizedCompletionListCapabilities struct { +type ResolvedCompletionListCapabilities struct { ItemDefaults []string ApplyKindSupport bool } -func finalizeCompletionListCapabilities(v *CompletionListCapabilities) FinalizedCompletionListCapabilities { +func resolveCompletionListCapabilities(v *CompletionListCapabilities) ResolvedCompletionListCapabilities { if v == nil { - return FinalizedCompletionListCapabilities{} + return ResolvedCompletionListCapabilities{} } - return FinalizedCompletionListCapabilities{ + return ResolvedCompletionListCapabilities{ ItemDefaults: derefOr(v.ItemDefaults), ApplyKindSupport: derefOr(v.ApplyKindSupport), } } -type FinalizedCompletionClientCapabilities struct { +type ResolvedCompletionClientCapabilities struct { DynamicRegistration bool - CompletionItem FinalizedClientCompletionItemOptions - CompletionItemKind FinalizedClientCompletionItemOptionsKind + CompletionItem ResolvedClientCompletionItemOptions + CompletionItemKind ResolvedClientCompletionItemOptionsKind InsertTextMode InsertTextMode ContextSupport bool - CompletionList FinalizedCompletionListCapabilities + CompletionList ResolvedCompletionListCapabilities } -func finalizeCompletionClientCapabilities(v *CompletionClientCapabilities) FinalizedCompletionClientCapabilities { +func resolveCompletionClientCapabilities(v *CompletionClientCapabilities) ResolvedCompletionClientCapabilities { if v == nil { - return FinalizedCompletionClientCapabilities{} + return ResolvedCompletionClientCapabilities{} } - return FinalizedCompletionClientCapabilities{ + return ResolvedCompletionClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - CompletionItem: finalizeClientCompletionItemOptions(v.CompletionItem), - CompletionItemKind: finalizeClientCompletionItemOptionsKind(v.CompletionItemKind), + CompletionItem: resolveClientCompletionItemOptions(v.CompletionItem), + CompletionItemKind: resolveClientCompletionItemOptionsKind(v.CompletionItemKind), InsertTextMode: derefOr(v.InsertTextMode), ContextSupport: derefOr(v.ContextSupport), - CompletionList: finalizeCompletionListCapabilities(v.CompletionList), + CompletionList: resolveCompletionListCapabilities(v.CompletionList), } } -type FinalizedHoverClientCapabilities struct { +type ResolvedHoverClientCapabilities struct { DynamicRegistration bool ContentFormat []MarkupKind } -func finalizeHoverClientCapabilities(v *HoverClientCapabilities) FinalizedHoverClientCapabilities { +func resolveHoverClientCapabilities(v *HoverClientCapabilities) ResolvedHoverClientCapabilities { if v == nil { - return FinalizedHoverClientCapabilities{} + return ResolvedHoverClientCapabilities{} } - return FinalizedHoverClientCapabilities{ + return ResolvedHoverClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), ContentFormat: derefOr(v.ContentFormat), } } -type FinalizedClientSignatureParameterInformationOptions struct { +type ResolvedClientSignatureParameterInformationOptions struct { LabelOffsetSupport bool } -func finalizeClientSignatureParameterInformationOptions(v *ClientSignatureParameterInformationOptions) FinalizedClientSignatureParameterInformationOptions { +func resolveClientSignatureParameterInformationOptions(v *ClientSignatureParameterInformationOptions) ResolvedClientSignatureParameterInformationOptions { if v == nil { - return FinalizedClientSignatureParameterInformationOptions{} + return ResolvedClientSignatureParameterInformationOptions{} } - return FinalizedClientSignatureParameterInformationOptions{ + return ResolvedClientSignatureParameterInformationOptions{ LabelOffsetSupport: derefOr(v.LabelOffsetSupport), } } -type FinalizedClientSignatureInformationOptions struct { +type ResolvedClientSignatureInformationOptions struct { DocumentationFormat []MarkupKind - ParameterInformation FinalizedClientSignatureParameterInformationOptions + ParameterInformation ResolvedClientSignatureParameterInformationOptions ActiveParameterSupport bool NoActiveParameterSupport bool } -func finalizeClientSignatureInformationOptions(v *ClientSignatureInformationOptions) FinalizedClientSignatureInformationOptions { +func resolveClientSignatureInformationOptions(v *ClientSignatureInformationOptions) ResolvedClientSignatureInformationOptions { if v == nil { - return FinalizedClientSignatureInformationOptions{} + return ResolvedClientSignatureInformationOptions{} } - return FinalizedClientSignatureInformationOptions{ + return ResolvedClientSignatureInformationOptions{ DocumentationFormat: derefOr(v.DocumentationFormat), - ParameterInformation: finalizeClientSignatureParameterInformationOptions(v.ParameterInformation), + ParameterInformation: resolveClientSignatureParameterInformationOptions(v.ParameterInformation), ActiveParameterSupport: derefOr(v.ActiveParameterSupport), NoActiveParameterSupport: derefOr(v.NoActiveParameterSupport), } } -type FinalizedSignatureHelpClientCapabilities struct { +type ResolvedSignatureHelpClientCapabilities struct { DynamicRegistration bool - SignatureInformation FinalizedClientSignatureInformationOptions + SignatureInformation ResolvedClientSignatureInformationOptions ContextSupport bool } -func finalizeSignatureHelpClientCapabilities(v *SignatureHelpClientCapabilities) FinalizedSignatureHelpClientCapabilities { +func resolveSignatureHelpClientCapabilities(v *SignatureHelpClientCapabilities) ResolvedSignatureHelpClientCapabilities { if v == nil { - return FinalizedSignatureHelpClientCapabilities{} + return ResolvedSignatureHelpClientCapabilities{} } - return FinalizedSignatureHelpClientCapabilities{ + return ResolvedSignatureHelpClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - SignatureInformation: finalizeClientSignatureInformationOptions(v.SignatureInformation), + SignatureInformation: resolveClientSignatureInformationOptions(v.SignatureInformation), ContextSupport: derefOr(v.ContextSupport), } } -type FinalizedDeclarationClientCapabilities struct { +type ResolvedDeclarationClientCapabilities struct { DynamicRegistration bool LinkSupport bool } -func finalizeDeclarationClientCapabilities(v *DeclarationClientCapabilities) FinalizedDeclarationClientCapabilities { +func resolveDeclarationClientCapabilities(v *DeclarationClientCapabilities) ResolvedDeclarationClientCapabilities { if v == nil { - return FinalizedDeclarationClientCapabilities{} + return ResolvedDeclarationClientCapabilities{} } - return FinalizedDeclarationClientCapabilities{ + return ResolvedDeclarationClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), LinkSupport: derefOr(v.LinkSupport), } } -type FinalizedDefinitionClientCapabilities struct { +type ResolvedDefinitionClientCapabilities struct { DynamicRegistration bool LinkSupport bool } -func finalizeDefinitionClientCapabilities(v *DefinitionClientCapabilities) FinalizedDefinitionClientCapabilities { +func resolveDefinitionClientCapabilities(v *DefinitionClientCapabilities) ResolvedDefinitionClientCapabilities { if v == nil { - return FinalizedDefinitionClientCapabilities{} + return ResolvedDefinitionClientCapabilities{} } - return FinalizedDefinitionClientCapabilities{ + return ResolvedDefinitionClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), LinkSupport: derefOr(v.LinkSupport), } } -type FinalizedTypeDefinitionClientCapabilities struct { +type ResolvedTypeDefinitionClientCapabilities struct { DynamicRegistration bool LinkSupport bool } -func finalizeTypeDefinitionClientCapabilities(v *TypeDefinitionClientCapabilities) FinalizedTypeDefinitionClientCapabilities { +func resolveTypeDefinitionClientCapabilities(v *TypeDefinitionClientCapabilities) ResolvedTypeDefinitionClientCapabilities { if v == nil { - return FinalizedTypeDefinitionClientCapabilities{} + return ResolvedTypeDefinitionClientCapabilities{} } - return FinalizedTypeDefinitionClientCapabilities{ + return ResolvedTypeDefinitionClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), LinkSupport: derefOr(v.LinkSupport), } } -type FinalizedImplementationClientCapabilities struct { +type ResolvedImplementationClientCapabilities struct { DynamicRegistration bool LinkSupport bool } -func finalizeImplementationClientCapabilities(v *ImplementationClientCapabilities) FinalizedImplementationClientCapabilities { +func resolveImplementationClientCapabilities(v *ImplementationClientCapabilities) ResolvedImplementationClientCapabilities { if v == nil { - return FinalizedImplementationClientCapabilities{} + return ResolvedImplementationClientCapabilities{} } - return FinalizedImplementationClientCapabilities{ + return ResolvedImplementationClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), LinkSupport: derefOr(v.LinkSupport), } } -type FinalizedReferenceClientCapabilities struct { +type ResolvedReferenceClientCapabilities struct { DynamicRegistration bool } -func finalizeReferenceClientCapabilities(v *ReferenceClientCapabilities) FinalizedReferenceClientCapabilities { +func resolveReferenceClientCapabilities(v *ReferenceClientCapabilities) ResolvedReferenceClientCapabilities { if v == nil { - return FinalizedReferenceClientCapabilities{} + return ResolvedReferenceClientCapabilities{} } - return FinalizedReferenceClientCapabilities{ + return ResolvedReferenceClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedDocumentHighlightClientCapabilities struct { +type ResolvedDocumentHighlightClientCapabilities struct { DynamicRegistration bool } -func finalizeDocumentHighlightClientCapabilities(v *DocumentHighlightClientCapabilities) FinalizedDocumentHighlightClientCapabilities { +func resolveDocumentHighlightClientCapabilities(v *DocumentHighlightClientCapabilities) ResolvedDocumentHighlightClientCapabilities { if v == nil { - return FinalizedDocumentHighlightClientCapabilities{} + return ResolvedDocumentHighlightClientCapabilities{} } - return FinalizedDocumentHighlightClientCapabilities{ + return ResolvedDocumentHighlightClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedDocumentSymbolClientCapabilities struct { +type ResolvedDocumentSymbolClientCapabilities struct { DynamicRegistration bool - SymbolKind FinalizedClientSymbolKindOptions + SymbolKind ResolvedClientSymbolKindOptions HierarchicalDocumentSymbolSupport bool - TagSupport FinalizedClientSymbolTagOptions + TagSupport ResolvedClientSymbolTagOptions LabelSupport bool } -func finalizeDocumentSymbolClientCapabilities(v *DocumentSymbolClientCapabilities) FinalizedDocumentSymbolClientCapabilities { +func resolveDocumentSymbolClientCapabilities(v *DocumentSymbolClientCapabilities) ResolvedDocumentSymbolClientCapabilities { if v == nil { - return FinalizedDocumentSymbolClientCapabilities{} + return ResolvedDocumentSymbolClientCapabilities{} } - return FinalizedDocumentSymbolClientCapabilities{ + return ResolvedDocumentSymbolClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - SymbolKind: finalizeClientSymbolKindOptions(v.SymbolKind), + SymbolKind: resolveClientSymbolKindOptions(v.SymbolKind), HierarchicalDocumentSymbolSupport: derefOr(v.HierarchicalDocumentSymbolSupport), - TagSupport: finalizeClientSymbolTagOptions(v.TagSupport), + TagSupport: resolveClientSymbolTagOptions(v.TagSupport), LabelSupport: derefOr(v.LabelSupport), } } -type FinalizedClientCodeActionKindOptions struct { +type ResolvedClientCodeActionKindOptions struct { ValueSet []CodeActionKind } -func finalizeClientCodeActionKindOptions(v *ClientCodeActionKindOptions) FinalizedClientCodeActionKindOptions { +func resolveClientCodeActionKindOptions(v *ClientCodeActionKindOptions) ResolvedClientCodeActionKindOptions { if v == nil { - return FinalizedClientCodeActionKindOptions{} + return ResolvedClientCodeActionKindOptions{} } - return FinalizedClientCodeActionKindOptions{ + return ResolvedClientCodeActionKindOptions{ ValueSet: v.ValueSet, } } -type FinalizedClientCodeActionLiteralOptions struct { - CodeActionKind FinalizedClientCodeActionKindOptions +type ResolvedClientCodeActionLiteralOptions struct { + CodeActionKind ResolvedClientCodeActionKindOptions } -func finalizeClientCodeActionLiteralOptions(v *ClientCodeActionLiteralOptions) FinalizedClientCodeActionLiteralOptions { +func resolveClientCodeActionLiteralOptions(v *ClientCodeActionLiteralOptions) ResolvedClientCodeActionLiteralOptions { if v == nil { - return FinalizedClientCodeActionLiteralOptions{} + return ResolvedClientCodeActionLiteralOptions{} } - return FinalizedClientCodeActionLiteralOptions{ - CodeActionKind: finalizeClientCodeActionKindOptions(v.CodeActionKind), + return ResolvedClientCodeActionLiteralOptions{ + CodeActionKind: resolveClientCodeActionKindOptions(v.CodeActionKind), } } -type FinalizedClientCodeActionResolveOptions struct { +type ResolvedClientCodeActionResolveOptions struct { Properties []string } -func finalizeClientCodeActionResolveOptions(v *ClientCodeActionResolveOptions) FinalizedClientCodeActionResolveOptions { +func resolveClientCodeActionResolveOptions(v *ClientCodeActionResolveOptions) ResolvedClientCodeActionResolveOptions { if v == nil { - return FinalizedClientCodeActionResolveOptions{} + return ResolvedClientCodeActionResolveOptions{} } - return FinalizedClientCodeActionResolveOptions{ + return ResolvedClientCodeActionResolveOptions{ Properties: v.Properties, } } -type FinalizedCodeActionTagOptions struct { +type ResolvedCodeActionTagOptions struct { ValueSet []CodeActionTag } -func finalizeCodeActionTagOptions(v *CodeActionTagOptions) FinalizedCodeActionTagOptions { +func resolveCodeActionTagOptions(v *CodeActionTagOptions) ResolvedCodeActionTagOptions { if v == nil { - return FinalizedCodeActionTagOptions{} + return ResolvedCodeActionTagOptions{} } - return FinalizedCodeActionTagOptions{ + return ResolvedCodeActionTagOptions{ ValueSet: v.ValueSet, } } -type FinalizedCodeActionClientCapabilities struct { +type ResolvedCodeActionClientCapabilities struct { DynamicRegistration bool - CodeActionLiteralSupport FinalizedClientCodeActionLiteralOptions + CodeActionLiteralSupport ResolvedClientCodeActionLiteralOptions IsPreferredSupport bool DisabledSupport bool DataSupport bool - ResolveSupport FinalizedClientCodeActionResolveOptions + ResolveSupport ResolvedClientCodeActionResolveOptions HonorsChangeAnnotations bool DocumentationSupport bool - TagSupport FinalizedCodeActionTagOptions + TagSupport ResolvedCodeActionTagOptions } -func finalizeCodeActionClientCapabilities(v *CodeActionClientCapabilities) FinalizedCodeActionClientCapabilities { +func resolveCodeActionClientCapabilities(v *CodeActionClientCapabilities) ResolvedCodeActionClientCapabilities { if v == nil { - return FinalizedCodeActionClientCapabilities{} + return ResolvedCodeActionClientCapabilities{} } - return FinalizedCodeActionClientCapabilities{ + return ResolvedCodeActionClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - CodeActionLiteralSupport: finalizeClientCodeActionLiteralOptions(v.CodeActionLiteralSupport), + CodeActionLiteralSupport: resolveClientCodeActionLiteralOptions(v.CodeActionLiteralSupport), IsPreferredSupport: derefOr(v.IsPreferredSupport), DisabledSupport: derefOr(v.DisabledSupport), DataSupport: derefOr(v.DataSupport), - ResolveSupport: finalizeClientCodeActionResolveOptions(v.ResolveSupport), + ResolveSupport: resolveClientCodeActionResolveOptions(v.ResolveSupport), HonorsChangeAnnotations: derefOr(v.HonorsChangeAnnotations), DocumentationSupport: derefOr(v.DocumentationSupport), - TagSupport: finalizeCodeActionTagOptions(v.TagSupport), + TagSupport: resolveCodeActionTagOptions(v.TagSupport), } } -type FinalizedClientCodeLensResolveOptions struct { +type ResolvedClientCodeLensResolveOptions struct { Properties []string } -func finalizeClientCodeLensResolveOptions(v *ClientCodeLensResolveOptions) FinalizedClientCodeLensResolveOptions { +func resolveClientCodeLensResolveOptions(v *ClientCodeLensResolveOptions) ResolvedClientCodeLensResolveOptions { if v == nil { - return FinalizedClientCodeLensResolveOptions{} + return ResolvedClientCodeLensResolveOptions{} } - return FinalizedClientCodeLensResolveOptions{ + return ResolvedClientCodeLensResolveOptions{ Properties: v.Properties, } } -type FinalizedCodeLensClientCapabilities struct { +type ResolvedCodeLensClientCapabilities struct { DynamicRegistration bool - ResolveSupport FinalizedClientCodeLensResolveOptions + ResolveSupport ResolvedClientCodeLensResolveOptions } -func finalizeCodeLensClientCapabilities(v *CodeLensClientCapabilities) FinalizedCodeLensClientCapabilities { +func resolveCodeLensClientCapabilities(v *CodeLensClientCapabilities) ResolvedCodeLensClientCapabilities { if v == nil { - return FinalizedCodeLensClientCapabilities{} + return ResolvedCodeLensClientCapabilities{} } - return FinalizedCodeLensClientCapabilities{ + return ResolvedCodeLensClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - ResolveSupport: finalizeClientCodeLensResolveOptions(v.ResolveSupport), + ResolveSupport: resolveClientCodeLensResolveOptions(v.ResolveSupport), } } -type FinalizedDocumentLinkClientCapabilities struct { +type ResolvedDocumentLinkClientCapabilities struct { DynamicRegistration bool TooltipSupport bool } -func finalizeDocumentLinkClientCapabilities(v *DocumentLinkClientCapabilities) FinalizedDocumentLinkClientCapabilities { +func resolveDocumentLinkClientCapabilities(v *DocumentLinkClientCapabilities) ResolvedDocumentLinkClientCapabilities { if v == nil { - return FinalizedDocumentLinkClientCapabilities{} + return ResolvedDocumentLinkClientCapabilities{} } - return FinalizedDocumentLinkClientCapabilities{ + return ResolvedDocumentLinkClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), TooltipSupport: derefOr(v.TooltipSupport), } } -type FinalizedDocumentColorClientCapabilities struct { +type ResolvedDocumentColorClientCapabilities struct { DynamicRegistration bool } -func finalizeDocumentColorClientCapabilities(v *DocumentColorClientCapabilities) FinalizedDocumentColorClientCapabilities { +func resolveDocumentColorClientCapabilities(v *DocumentColorClientCapabilities) ResolvedDocumentColorClientCapabilities { if v == nil { - return FinalizedDocumentColorClientCapabilities{} + return ResolvedDocumentColorClientCapabilities{} } - return FinalizedDocumentColorClientCapabilities{ + return ResolvedDocumentColorClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedDocumentFormattingClientCapabilities struct { +type ResolvedDocumentFormattingClientCapabilities struct { DynamicRegistration bool } -func finalizeDocumentFormattingClientCapabilities(v *DocumentFormattingClientCapabilities) FinalizedDocumentFormattingClientCapabilities { +func resolveDocumentFormattingClientCapabilities(v *DocumentFormattingClientCapabilities) ResolvedDocumentFormattingClientCapabilities { if v == nil { - return FinalizedDocumentFormattingClientCapabilities{} + return ResolvedDocumentFormattingClientCapabilities{} } - return FinalizedDocumentFormattingClientCapabilities{ + return ResolvedDocumentFormattingClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedDocumentRangeFormattingClientCapabilities struct { +type ResolvedDocumentRangeFormattingClientCapabilities struct { DynamicRegistration bool RangesSupport bool } -func finalizeDocumentRangeFormattingClientCapabilities(v *DocumentRangeFormattingClientCapabilities) FinalizedDocumentRangeFormattingClientCapabilities { +func resolveDocumentRangeFormattingClientCapabilities(v *DocumentRangeFormattingClientCapabilities) ResolvedDocumentRangeFormattingClientCapabilities { if v == nil { - return FinalizedDocumentRangeFormattingClientCapabilities{} + return ResolvedDocumentRangeFormattingClientCapabilities{} } - return FinalizedDocumentRangeFormattingClientCapabilities{ + return ResolvedDocumentRangeFormattingClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), RangesSupport: derefOr(v.RangesSupport), } } -type FinalizedDocumentOnTypeFormattingClientCapabilities struct { +type ResolvedDocumentOnTypeFormattingClientCapabilities struct { DynamicRegistration bool } -func finalizeDocumentOnTypeFormattingClientCapabilities(v *DocumentOnTypeFormattingClientCapabilities) FinalizedDocumentOnTypeFormattingClientCapabilities { +func resolveDocumentOnTypeFormattingClientCapabilities(v *DocumentOnTypeFormattingClientCapabilities) ResolvedDocumentOnTypeFormattingClientCapabilities { if v == nil { - return FinalizedDocumentOnTypeFormattingClientCapabilities{} + return ResolvedDocumentOnTypeFormattingClientCapabilities{} } - return FinalizedDocumentOnTypeFormattingClientCapabilities{ + return ResolvedDocumentOnTypeFormattingClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedRenameClientCapabilities struct { +type ResolvedRenameClientCapabilities struct { DynamicRegistration bool PrepareSupport bool PrepareSupportDefaultBehavior PrepareSupportDefaultBehavior HonorsChangeAnnotations bool } -func finalizeRenameClientCapabilities(v *RenameClientCapabilities) FinalizedRenameClientCapabilities { +func resolveRenameClientCapabilities(v *RenameClientCapabilities) ResolvedRenameClientCapabilities { if v == nil { - return FinalizedRenameClientCapabilities{} + return ResolvedRenameClientCapabilities{} } - return FinalizedRenameClientCapabilities{ + return ResolvedRenameClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), PrepareSupport: derefOr(v.PrepareSupport), PrepareSupportDefaultBehavior: derefOr(v.PrepareSupportDefaultBehavior), @@ -26552,131 +26552,131 @@ func finalizeRenameClientCapabilities(v *RenameClientCapabilities) FinalizedRena } } -type FinalizedClientFoldingRangeKindOptions struct { +type ResolvedClientFoldingRangeKindOptions struct { ValueSet []FoldingRangeKind } -func finalizeClientFoldingRangeKindOptions(v *ClientFoldingRangeKindOptions) FinalizedClientFoldingRangeKindOptions { +func resolveClientFoldingRangeKindOptions(v *ClientFoldingRangeKindOptions) ResolvedClientFoldingRangeKindOptions { if v == nil { - return FinalizedClientFoldingRangeKindOptions{} + return ResolvedClientFoldingRangeKindOptions{} } - return FinalizedClientFoldingRangeKindOptions{ + return ResolvedClientFoldingRangeKindOptions{ ValueSet: derefOr(v.ValueSet), } } -type FinalizedClientFoldingRangeOptions struct { +type ResolvedClientFoldingRangeOptions struct { CollapsedText bool } -func finalizeClientFoldingRangeOptions(v *ClientFoldingRangeOptions) FinalizedClientFoldingRangeOptions { +func resolveClientFoldingRangeOptions(v *ClientFoldingRangeOptions) ResolvedClientFoldingRangeOptions { if v == nil { - return FinalizedClientFoldingRangeOptions{} + return ResolvedClientFoldingRangeOptions{} } - return FinalizedClientFoldingRangeOptions{ + return ResolvedClientFoldingRangeOptions{ CollapsedText: derefOr(v.CollapsedText), } } -type FinalizedFoldingRangeClientCapabilities struct { +type ResolvedFoldingRangeClientCapabilities struct { DynamicRegistration bool RangeLimit uint32 LineFoldingOnly bool - FoldingRangeKind FinalizedClientFoldingRangeKindOptions - FoldingRange FinalizedClientFoldingRangeOptions + FoldingRangeKind ResolvedClientFoldingRangeKindOptions + FoldingRange ResolvedClientFoldingRangeOptions } -func finalizeFoldingRangeClientCapabilities(v *FoldingRangeClientCapabilities) FinalizedFoldingRangeClientCapabilities { +func resolveFoldingRangeClientCapabilities(v *FoldingRangeClientCapabilities) ResolvedFoldingRangeClientCapabilities { if v == nil { - return FinalizedFoldingRangeClientCapabilities{} + return ResolvedFoldingRangeClientCapabilities{} } - return FinalizedFoldingRangeClientCapabilities{ + return ResolvedFoldingRangeClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), RangeLimit: derefOr(v.RangeLimit), LineFoldingOnly: derefOr(v.LineFoldingOnly), - FoldingRangeKind: finalizeClientFoldingRangeKindOptions(v.FoldingRangeKind), - FoldingRange: finalizeClientFoldingRangeOptions(v.FoldingRange), + FoldingRangeKind: resolveClientFoldingRangeKindOptions(v.FoldingRangeKind), + FoldingRange: resolveClientFoldingRangeOptions(v.FoldingRange), } } -type FinalizedSelectionRangeClientCapabilities struct { +type ResolvedSelectionRangeClientCapabilities struct { DynamicRegistration bool } -func finalizeSelectionRangeClientCapabilities(v *SelectionRangeClientCapabilities) FinalizedSelectionRangeClientCapabilities { +func resolveSelectionRangeClientCapabilities(v *SelectionRangeClientCapabilities) ResolvedSelectionRangeClientCapabilities { if v == nil { - return FinalizedSelectionRangeClientCapabilities{} + return ResolvedSelectionRangeClientCapabilities{} } - return FinalizedSelectionRangeClientCapabilities{ + return ResolvedSelectionRangeClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedClientDiagnosticsTagOptions struct { +type ResolvedClientDiagnosticsTagOptions struct { ValueSet []DiagnosticTag } -func finalizeClientDiagnosticsTagOptions(v *ClientDiagnosticsTagOptions) FinalizedClientDiagnosticsTagOptions { +func resolveClientDiagnosticsTagOptions(v *ClientDiagnosticsTagOptions) ResolvedClientDiagnosticsTagOptions { if v == nil { - return FinalizedClientDiagnosticsTagOptions{} + return ResolvedClientDiagnosticsTagOptions{} } - return FinalizedClientDiagnosticsTagOptions{ + return ResolvedClientDiagnosticsTagOptions{ ValueSet: v.ValueSet, } } -type FinalizedPublishDiagnosticsClientCapabilities struct { +type ResolvedPublishDiagnosticsClientCapabilities struct { RelatedInformation bool - TagSupport FinalizedClientDiagnosticsTagOptions + TagSupport ResolvedClientDiagnosticsTagOptions CodeDescriptionSupport bool DataSupport bool VersionSupport bool } -func finalizePublishDiagnosticsClientCapabilities(v *PublishDiagnosticsClientCapabilities) FinalizedPublishDiagnosticsClientCapabilities { +func resolvePublishDiagnosticsClientCapabilities(v *PublishDiagnosticsClientCapabilities) ResolvedPublishDiagnosticsClientCapabilities { if v == nil { - return FinalizedPublishDiagnosticsClientCapabilities{} + return ResolvedPublishDiagnosticsClientCapabilities{} } - return FinalizedPublishDiagnosticsClientCapabilities{ + return ResolvedPublishDiagnosticsClientCapabilities{ RelatedInformation: derefOr(v.RelatedInformation), - TagSupport: finalizeClientDiagnosticsTagOptions(v.TagSupport), + TagSupport: resolveClientDiagnosticsTagOptions(v.TagSupport), CodeDescriptionSupport: derefOr(v.CodeDescriptionSupport), DataSupport: derefOr(v.DataSupport), VersionSupport: derefOr(v.VersionSupport), } } -type FinalizedCallHierarchyClientCapabilities struct { +type ResolvedCallHierarchyClientCapabilities struct { DynamicRegistration bool } -func finalizeCallHierarchyClientCapabilities(v *CallHierarchyClientCapabilities) FinalizedCallHierarchyClientCapabilities { +func resolveCallHierarchyClientCapabilities(v *CallHierarchyClientCapabilities) ResolvedCallHierarchyClientCapabilities { if v == nil { - return FinalizedCallHierarchyClientCapabilities{} + return ResolvedCallHierarchyClientCapabilities{} } - return FinalizedCallHierarchyClientCapabilities{ + return ResolvedCallHierarchyClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedClientSemanticTokensRequestOptions struct { +type ResolvedClientSemanticTokensRequestOptions struct { Range BooleanOrEmptyObject Full BooleanOrClientSemanticTokensRequestFullDelta } -func finalizeClientSemanticTokensRequestOptions(v *ClientSemanticTokensRequestOptions) FinalizedClientSemanticTokensRequestOptions { +func resolveClientSemanticTokensRequestOptions(v *ClientSemanticTokensRequestOptions) ResolvedClientSemanticTokensRequestOptions { if v == nil { - return FinalizedClientSemanticTokensRequestOptions{} + return ResolvedClientSemanticTokensRequestOptions{} } - return FinalizedClientSemanticTokensRequestOptions{ + return ResolvedClientSemanticTokensRequestOptions{ Range: derefOr(v.Range), Full: derefOr(v.Full), } } -type FinalizedSemanticTokensClientCapabilities struct { +type ResolvedSemanticTokensClientCapabilities struct { DynamicRegistration bool - Requests FinalizedClientSemanticTokensRequestOptions + Requests ResolvedClientSemanticTokensRequestOptions TokenTypes []string TokenModifiers []string Formats []TokenFormat @@ -26686,13 +26686,13 @@ type FinalizedSemanticTokensClientCapabilities struct { AugmentsSyntaxTokens bool } -func finalizeSemanticTokensClientCapabilities(v *SemanticTokensClientCapabilities) FinalizedSemanticTokensClientCapabilities { +func resolveSemanticTokensClientCapabilities(v *SemanticTokensClientCapabilities) ResolvedSemanticTokensClientCapabilities { if v == nil { - return FinalizedSemanticTokensClientCapabilities{} + return ResolvedSemanticTokensClientCapabilities{} } - return FinalizedSemanticTokensClientCapabilities{ + return ResolvedSemanticTokensClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - Requests: finalizeClientSemanticTokensRequestOptions(v.Requests), + Requests: resolveClientSemanticTokensRequestOptions(v.Requests), TokenTypes: v.TokenTypes, TokenModifiers: v.TokenModifiers, Formats: v.Formats, @@ -26703,102 +26703,102 @@ func finalizeSemanticTokensClientCapabilities(v *SemanticTokensClientCapabilitie } } -type FinalizedLinkedEditingRangeClientCapabilities struct { +type ResolvedLinkedEditingRangeClientCapabilities struct { DynamicRegistration bool } -func finalizeLinkedEditingRangeClientCapabilities(v *LinkedEditingRangeClientCapabilities) FinalizedLinkedEditingRangeClientCapabilities { +func resolveLinkedEditingRangeClientCapabilities(v *LinkedEditingRangeClientCapabilities) ResolvedLinkedEditingRangeClientCapabilities { if v == nil { - return FinalizedLinkedEditingRangeClientCapabilities{} + return ResolvedLinkedEditingRangeClientCapabilities{} } - return FinalizedLinkedEditingRangeClientCapabilities{ + return ResolvedLinkedEditingRangeClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedMonikerClientCapabilities struct { +type ResolvedMonikerClientCapabilities struct { DynamicRegistration bool } -func finalizeMonikerClientCapabilities(v *MonikerClientCapabilities) FinalizedMonikerClientCapabilities { +func resolveMonikerClientCapabilities(v *MonikerClientCapabilities) ResolvedMonikerClientCapabilities { if v == nil { - return FinalizedMonikerClientCapabilities{} + return ResolvedMonikerClientCapabilities{} } - return FinalizedMonikerClientCapabilities{ + return ResolvedMonikerClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedTypeHierarchyClientCapabilities struct { +type ResolvedTypeHierarchyClientCapabilities struct { DynamicRegistration bool } -func finalizeTypeHierarchyClientCapabilities(v *TypeHierarchyClientCapabilities) FinalizedTypeHierarchyClientCapabilities { +func resolveTypeHierarchyClientCapabilities(v *TypeHierarchyClientCapabilities) ResolvedTypeHierarchyClientCapabilities { if v == nil { - return FinalizedTypeHierarchyClientCapabilities{} + return ResolvedTypeHierarchyClientCapabilities{} } - return FinalizedTypeHierarchyClientCapabilities{ + return ResolvedTypeHierarchyClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedInlineValueClientCapabilities struct { +type ResolvedInlineValueClientCapabilities struct { DynamicRegistration bool } -func finalizeInlineValueClientCapabilities(v *InlineValueClientCapabilities) FinalizedInlineValueClientCapabilities { +func resolveInlineValueClientCapabilities(v *InlineValueClientCapabilities) ResolvedInlineValueClientCapabilities { if v == nil { - return FinalizedInlineValueClientCapabilities{} + return ResolvedInlineValueClientCapabilities{} } - return FinalizedInlineValueClientCapabilities{ + return ResolvedInlineValueClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedClientInlayHintResolveOptions struct { +type ResolvedClientInlayHintResolveOptions struct { Properties []string } -func finalizeClientInlayHintResolveOptions(v *ClientInlayHintResolveOptions) FinalizedClientInlayHintResolveOptions { +func resolveClientInlayHintResolveOptions(v *ClientInlayHintResolveOptions) ResolvedClientInlayHintResolveOptions { if v == nil { - return FinalizedClientInlayHintResolveOptions{} + return ResolvedClientInlayHintResolveOptions{} } - return FinalizedClientInlayHintResolveOptions{ + return ResolvedClientInlayHintResolveOptions{ Properties: v.Properties, } } -type FinalizedInlayHintClientCapabilities struct { +type ResolvedInlayHintClientCapabilities struct { DynamicRegistration bool - ResolveSupport FinalizedClientInlayHintResolveOptions + ResolveSupport ResolvedClientInlayHintResolveOptions } -func finalizeInlayHintClientCapabilities(v *InlayHintClientCapabilities) FinalizedInlayHintClientCapabilities { +func resolveInlayHintClientCapabilities(v *InlayHintClientCapabilities) ResolvedInlayHintClientCapabilities { if v == nil { - return FinalizedInlayHintClientCapabilities{} + return ResolvedInlayHintClientCapabilities{} } - return FinalizedInlayHintClientCapabilities{ + return ResolvedInlayHintClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), - ResolveSupport: finalizeClientInlayHintResolveOptions(v.ResolveSupport), + ResolveSupport: resolveClientInlayHintResolveOptions(v.ResolveSupport), } } -type FinalizedDiagnosticClientCapabilities struct { +type ResolvedDiagnosticClientCapabilities struct { RelatedInformation bool - TagSupport FinalizedClientDiagnosticsTagOptions + TagSupport ResolvedClientDiagnosticsTagOptions CodeDescriptionSupport bool DataSupport bool DynamicRegistration bool RelatedDocumentSupport bool } -func finalizeDiagnosticClientCapabilities(v *DiagnosticClientCapabilities) FinalizedDiagnosticClientCapabilities { +func resolveDiagnosticClientCapabilities(v *DiagnosticClientCapabilities) ResolvedDiagnosticClientCapabilities { if v == nil { - return FinalizedDiagnosticClientCapabilities{} + return ResolvedDiagnosticClientCapabilities{} } - return FinalizedDiagnosticClientCapabilities{ + return ResolvedDiagnosticClientCapabilities{ RelatedInformation: derefOr(v.RelatedInformation), - TagSupport: finalizeClientDiagnosticsTagOptions(v.TagSupport), + TagSupport: resolveClientDiagnosticsTagOptions(v.TagSupport), CodeDescriptionSupport: derefOr(v.CodeDescriptionSupport), DataSupport: derefOr(v.DataSupport), DynamicRegistration: derefOr(v.DynamicRegistration), @@ -26806,266 +26806,266 @@ func finalizeDiagnosticClientCapabilities(v *DiagnosticClientCapabilities) Final } } -type FinalizedInlineCompletionClientCapabilities struct { +type ResolvedInlineCompletionClientCapabilities struct { DynamicRegistration bool } -func finalizeInlineCompletionClientCapabilities(v *InlineCompletionClientCapabilities) FinalizedInlineCompletionClientCapabilities { +func resolveInlineCompletionClientCapabilities(v *InlineCompletionClientCapabilities) ResolvedInlineCompletionClientCapabilities { if v == nil { - return FinalizedInlineCompletionClientCapabilities{} + return ResolvedInlineCompletionClientCapabilities{} } - return FinalizedInlineCompletionClientCapabilities{ + return ResolvedInlineCompletionClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), } } -type FinalizedTextDocumentClientCapabilities struct { - Synchronization FinalizedTextDocumentSyncClientCapabilities - Filters FinalizedTextDocumentFilterClientCapabilities - Completion FinalizedCompletionClientCapabilities - Hover FinalizedHoverClientCapabilities - SignatureHelp FinalizedSignatureHelpClientCapabilities - Declaration FinalizedDeclarationClientCapabilities - Definition FinalizedDefinitionClientCapabilities - TypeDefinition FinalizedTypeDefinitionClientCapabilities - Implementation FinalizedImplementationClientCapabilities - References FinalizedReferenceClientCapabilities - DocumentHighlight FinalizedDocumentHighlightClientCapabilities - DocumentSymbol FinalizedDocumentSymbolClientCapabilities - CodeAction FinalizedCodeActionClientCapabilities - CodeLens FinalizedCodeLensClientCapabilities - DocumentLink FinalizedDocumentLinkClientCapabilities - ColorProvider FinalizedDocumentColorClientCapabilities - Formatting FinalizedDocumentFormattingClientCapabilities - RangeFormatting FinalizedDocumentRangeFormattingClientCapabilities - OnTypeFormatting FinalizedDocumentOnTypeFormattingClientCapabilities - Rename FinalizedRenameClientCapabilities - FoldingRange FinalizedFoldingRangeClientCapabilities - SelectionRange FinalizedSelectionRangeClientCapabilities - PublishDiagnostics FinalizedPublishDiagnosticsClientCapabilities - CallHierarchy FinalizedCallHierarchyClientCapabilities - SemanticTokens FinalizedSemanticTokensClientCapabilities - LinkedEditingRange FinalizedLinkedEditingRangeClientCapabilities - Moniker FinalizedMonikerClientCapabilities - TypeHierarchy FinalizedTypeHierarchyClientCapabilities - InlineValue FinalizedInlineValueClientCapabilities - InlayHint FinalizedInlayHintClientCapabilities - Diagnostic FinalizedDiagnosticClientCapabilities - InlineCompletion FinalizedInlineCompletionClientCapabilities -} - -func finalizeTextDocumentClientCapabilities(v *TextDocumentClientCapabilities) FinalizedTextDocumentClientCapabilities { +type ResolvedTextDocumentClientCapabilities struct { + Synchronization ResolvedTextDocumentSyncClientCapabilities + Filters ResolvedTextDocumentFilterClientCapabilities + Completion ResolvedCompletionClientCapabilities + Hover ResolvedHoverClientCapabilities + SignatureHelp ResolvedSignatureHelpClientCapabilities + Declaration ResolvedDeclarationClientCapabilities + Definition ResolvedDefinitionClientCapabilities + TypeDefinition ResolvedTypeDefinitionClientCapabilities + Implementation ResolvedImplementationClientCapabilities + References ResolvedReferenceClientCapabilities + DocumentHighlight ResolvedDocumentHighlightClientCapabilities + DocumentSymbol ResolvedDocumentSymbolClientCapabilities + CodeAction ResolvedCodeActionClientCapabilities + CodeLens ResolvedCodeLensClientCapabilities + DocumentLink ResolvedDocumentLinkClientCapabilities + ColorProvider ResolvedDocumentColorClientCapabilities + Formatting ResolvedDocumentFormattingClientCapabilities + RangeFormatting ResolvedDocumentRangeFormattingClientCapabilities + OnTypeFormatting ResolvedDocumentOnTypeFormattingClientCapabilities + Rename ResolvedRenameClientCapabilities + FoldingRange ResolvedFoldingRangeClientCapabilities + SelectionRange ResolvedSelectionRangeClientCapabilities + PublishDiagnostics ResolvedPublishDiagnosticsClientCapabilities + CallHierarchy ResolvedCallHierarchyClientCapabilities + SemanticTokens ResolvedSemanticTokensClientCapabilities + LinkedEditingRange ResolvedLinkedEditingRangeClientCapabilities + Moniker ResolvedMonikerClientCapabilities + TypeHierarchy ResolvedTypeHierarchyClientCapabilities + InlineValue ResolvedInlineValueClientCapabilities + InlayHint ResolvedInlayHintClientCapabilities + Diagnostic ResolvedDiagnosticClientCapabilities + InlineCompletion ResolvedInlineCompletionClientCapabilities +} + +func resolveTextDocumentClientCapabilities(v *TextDocumentClientCapabilities) ResolvedTextDocumentClientCapabilities { if v == nil { - return FinalizedTextDocumentClientCapabilities{} - } - return FinalizedTextDocumentClientCapabilities{ - Synchronization: finalizeTextDocumentSyncClientCapabilities(v.Synchronization), - Filters: finalizeTextDocumentFilterClientCapabilities(v.Filters), - Completion: finalizeCompletionClientCapabilities(v.Completion), - Hover: finalizeHoverClientCapabilities(v.Hover), - SignatureHelp: finalizeSignatureHelpClientCapabilities(v.SignatureHelp), - Declaration: finalizeDeclarationClientCapabilities(v.Declaration), - Definition: finalizeDefinitionClientCapabilities(v.Definition), - TypeDefinition: finalizeTypeDefinitionClientCapabilities(v.TypeDefinition), - Implementation: finalizeImplementationClientCapabilities(v.Implementation), - References: finalizeReferenceClientCapabilities(v.References), - DocumentHighlight: finalizeDocumentHighlightClientCapabilities(v.DocumentHighlight), - DocumentSymbol: finalizeDocumentSymbolClientCapabilities(v.DocumentSymbol), - CodeAction: finalizeCodeActionClientCapabilities(v.CodeAction), - CodeLens: finalizeCodeLensClientCapabilities(v.CodeLens), - DocumentLink: finalizeDocumentLinkClientCapabilities(v.DocumentLink), - ColorProvider: finalizeDocumentColorClientCapabilities(v.ColorProvider), - Formatting: finalizeDocumentFormattingClientCapabilities(v.Formatting), - RangeFormatting: finalizeDocumentRangeFormattingClientCapabilities(v.RangeFormatting), - OnTypeFormatting: finalizeDocumentOnTypeFormattingClientCapabilities(v.OnTypeFormatting), - Rename: finalizeRenameClientCapabilities(v.Rename), - FoldingRange: finalizeFoldingRangeClientCapabilities(v.FoldingRange), - SelectionRange: finalizeSelectionRangeClientCapabilities(v.SelectionRange), - PublishDiagnostics: finalizePublishDiagnosticsClientCapabilities(v.PublishDiagnostics), - CallHierarchy: finalizeCallHierarchyClientCapabilities(v.CallHierarchy), - SemanticTokens: finalizeSemanticTokensClientCapabilities(v.SemanticTokens), - LinkedEditingRange: finalizeLinkedEditingRangeClientCapabilities(v.LinkedEditingRange), - Moniker: finalizeMonikerClientCapabilities(v.Moniker), - TypeHierarchy: finalizeTypeHierarchyClientCapabilities(v.TypeHierarchy), - InlineValue: finalizeInlineValueClientCapabilities(v.InlineValue), - InlayHint: finalizeInlayHintClientCapabilities(v.InlayHint), - Diagnostic: finalizeDiagnosticClientCapabilities(v.Diagnostic), - InlineCompletion: finalizeInlineCompletionClientCapabilities(v.InlineCompletion), - } -} - -type FinalizedNotebookDocumentSyncClientCapabilities struct { + return ResolvedTextDocumentClientCapabilities{} + } + return ResolvedTextDocumentClientCapabilities{ + Synchronization: resolveTextDocumentSyncClientCapabilities(v.Synchronization), + Filters: resolveTextDocumentFilterClientCapabilities(v.Filters), + Completion: resolveCompletionClientCapabilities(v.Completion), + Hover: resolveHoverClientCapabilities(v.Hover), + SignatureHelp: resolveSignatureHelpClientCapabilities(v.SignatureHelp), + Declaration: resolveDeclarationClientCapabilities(v.Declaration), + Definition: resolveDefinitionClientCapabilities(v.Definition), + TypeDefinition: resolveTypeDefinitionClientCapabilities(v.TypeDefinition), + Implementation: resolveImplementationClientCapabilities(v.Implementation), + References: resolveReferenceClientCapabilities(v.References), + DocumentHighlight: resolveDocumentHighlightClientCapabilities(v.DocumentHighlight), + DocumentSymbol: resolveDocumentSymbolClientCapabilities(v.DocumentSymbol), + CodeAction: resolveCodeActionClientCapabilities(v.CodeAction), + CodeLens: resolveCodeLensClientCapabilities(v.CodeLens), + DocumentLink: resolveDocumentLinkClientCapabilities(v.DocumentLink), + ColorProvider: resolveDocumentColorClientCapabilities(v.ColorProvider), + Formatting: resolveDocumentFormattingClientCapabilities(v.Formatting), + RangeFormatting: resolveDocumentRangeFormattingClientCapabilities(v.RangeFormatting), + OnTypeFormatting: resolveDocumentOnTypeFormattingClientCapabilities(v.OnTypeFormatting), + Rename: resolveRenameClientCapabilities(v.Rename), + FoldingRange: resolveFoldingRangeClientCapabilities(v.FoldingRange), + SelectionRange: resolveSelectionRangeClientCapabilities(v.SelectionRange), + PublishDiagnostics: resolvePublishDiagnosticsClientCapabilities(v.PublishDiagnostics), + CallHierarchy: resolveCallHierarchyClientCapabilities(v.CallHierarchy), + SemanticTokens: resolveSemanticTokensClientCapabilities(v.SemanticTokens), + LinkedEditingRange: resolveLinkedEditingRangeClientCapabilities(v.LinkedEditingRange), + Moniker: resolveMonikerClientCapabilities(v.Moniker), + TypeHierarchy: resolveTypeHierarchyClientCapabilities(v.TypeHierarchy), + InlineValue: resolveInlineValueClientCapabilities(v.InlineValue), + InlayHint: resolveInlayHintClientCapabilities(v.InlayHint), + Diagnostic: resolveDiagnosticClientCapabilities(v.Diagnostic), + InlineCompletion: resolveInlineCompletionClientCapabilities(v.InlineCompletion), + } +} + +type ResolvedNotebookDocumentSyncClientCapabilities struct { DynamicRegistration bool ExecutionSummarySupport bool } -func finalizeNotebookDocumentSyncClientCapabilities(v *NotebookDocumentSyncClientCapabilities) FinalizedNotebookDocumentSyncClientCapabilities { +func resolveNotebookDocumentSyncClientCapabilities(v *NotebookDocumentSyncClientCapabilities) ResolvedNotebookDocumentSyncClientCapabilities { if v == nil { - return FinalizedNotebookDocumentSyncClientCapabilities{} + return ResolvedNotebookDocumentSyncClientCapabilities{} } - return FinalizedNotebookDocumentSyncClientCapabilities{ + return ResolvedNotebookDocumentSyncClientCapabilities{ DynamicRegistration: derefOr(v.DynamicRegistration), ExecutionSummarySupport: derefOr(v.ExecutionSummarySupport), } } -type FinalizedNotebookDocumentClientCapabilities struct { - Synchronization FinalizedNotebookDocumentSyncClientCapabilities +type ResolvedNotebookDocumentClientCapabilities struct { + Synchronization ResolvedNotebookDocumentSyncClientCapabilities } -func finalizeNotebookDocumentClientCapabilities(v *NotebookDocumentClientCapabilities) FinalizedNotebookDocumentClientCapabilities { +func resolveNotebookDocumentClientCapabilities(v *NotebookDocumentClientCapabilities) ResolvedNotebookDocumentClientCapabilities { if v == nil { - return FinalizedNotebookDocumentClientCapabilities{} + return ResolvedNotebookDocumentClientCapabilities{} } - return FinalizedNotebookDocumentClientCapabilities{ - Synchronization: finalizeNotebookDocumentSyncClientCapabilities(v.Synchronization), + return ResolvedNotebookDocumentClientCapabilities{ + Synchronization: resolveNotebookDocumentSyncClientCapabilities(v.Synchronization), } } -type FinalizedClientShowMessageActionItemOptions struct { +type ResolvedClientShowMessageActionItemOptions struct { AdditionalPropertiesSupport bool } -func finalizeClientShowMessageActionItemOptions(v *ClientShowMessageActionItemOptions) FinalizedClientShowMessageActionItemOptions { +func resolveClientShowMessageActionItemOptions(v *ClientShowMessageActionItemOptions) ResolvedClientShowMessageActionItemOptions { if v == nil { - return FinalizedClientShowMessageActionItemOptions{} + return ResolvedClientShowMessageActionItemOptions{} } - return FinalizedClientShowMessageActionItemOptions{ + return ResolvedClientShowMessageActionItemOptions{ AdditionalPropertiesSupport: derefOr(v.AdditionalPropertiesSupport), } } -type FinalizedShowMessageRequestClientCapabilities struct { - MessageActionItem FinalizedClientShowMessageActionItemOptions +type ResolvedShowMessageRequestClientCapabilities struct { + MessageActionItem ResolvedClientShowMessageActionItemOptions } -func finalizeShowMessageRequestClientCapabilities(v *ShowMessageRequestClientCapabilities) FinalizedShowMessageRequestClientCapabilities { +func resolveShowMessageRequestClientCapabilities(v *ShowMessageRequestClientCapabilities) ResolvedShowMessageRequestClientCapabilities { if v == nil { - return FinalizedShowMessageRequestClientCapabilities{} + return ResolvedShowMessageRequestClientCapabilities{} } - return FinalizedShowMessageRequestClientCapabilities{ - MessageActionItem: finalizeClientShowMessageActionItemOptions(v.MessageActionItem), + return ResolvedShowMessageRequestClientCapabilities{ + MessageActionItem: resolveClientShowMessageActionItemOptions(v.MessageActionItem), } } -type FinalizedShowDocumentClientCapabilities struct { +type ResolvedShowDocumentClientCapabilities struct { Support bool } -func finalizeShowDocumentClientCapabilities(v *ShowDocumentClientCapabilities) FinalizedShowDocumentClientCapabilities { +func resolveShowDocumentClientCapabilities(v *ShowDocumentClientCapabilities) ResolvedShowDocumentClientCapabilities { if v == nil { - return FinalizedShowDocumentClientCapabilities{} + return ResolvedShowDocumentClientCapabilities{} } - return FinalizedShowDocumentClientCapabilities{ + return ResolvedShowDocumentClientCapabilities{ Support: v.Support, } } -type FinalizedWindowClientCapabilities struct { +type ResolvedWindowClientCapabilities struct { WorkDoneProgress bool - ShowMessage FinalizedShowMessageRequestClientCapabilities - ShowDocument FinalizedShowDocumentClientCapabilities + ShowMessage ResolvedShowMessageRequestClientCapabilities + ShowDocument ResolvedShowDocumentClientCapabilities } -func finalizeWindowClientCapabilities(v *WindowClientCapabilities) FinalizedWindowClientCapabilities { +func resolveWindowClientCapabilities(v *WindowClientCapabilities) ResolvedWindowClientCapabilities { if v == nil { - return FinalizedWindowClientCapabilities{} + return ResolvedWindowClientCapabilities{} } - return FinalizedWindowClientCapabilities{ + return ResolvedWindowClientCapabilities{ WorkDoneProgress: derefOr(v.WorkDoneProgress), - ShowMessage: finalizeShowMessageRequestClientCapabilities(v.ShowMessage), - ShowDocument: finalizeShowDocumentClientCapabilities(v.ShowDocument), + ShowMessage: resolveShowMessageRequestClientCapabilities(v.ShowMessage), + ShowDocument: resolveShowDocumentClientCapabilities(v.ShowDocument), } } -type FinalizedStaleRequestSupportOptions struct { +type ResolvedStaleRequestSupportOptions struct { Cancel bool RetryOnContentModified []string } -func finalizeStaleRequestSupportOptions(v *StaleRequestSupportOptions) FinalizedStaleRequestSupportOptions { +func resolveStaleRequestSupportOptions(v *StaleRequestSupportOptions) ResolvedStaleRequestSupportOptions { if v == nil { - return FinalizedStaleRequestSupportOptions{} + return ResolvedStaleRequestSupportOptions{} } - return FinalizedStaleRequestSupportOptions{ + return ResolvedStaleRequestSupportOptions{ Cancel: v.Cancel, RetryOnContentModified: v.RetryOnContentModified, } } -type FinalizedRegularExpressionsClientCapabilities struct { +type ResolvedRegularExpressionsClientCapabilities struct { Engine string Version string } -func finalizeRegularExpressionsClientCapabilities(v *RegularExpressionsClientCapabilities) FinalizedRegularExpressionsClientCapabilities { +func resolveRegularExpressionsClientCapabilities(v *RegularExpressionsClientCapabilities) ResolvedRegularExpressionsClientCapabilities { if v == nil { - return FinalizedRegularExpressionsClientCapabilities{} + return ResolvedRegularExpressionsClientCapabilities{} } - return FinalizedRegularExpressionsClientCapabilities{ + return ResolvedRegularExpressionsClientCapabilities{ Engine: v.Engine, Version: derefOr(v.Version), } } -type FinalizedMarkdownClientCapabilities struct { +type ResolvedMarkdownClientCapabilities struct { Parser string Version string AllowedTags []string } -func finalizeMarkdownClientCapabilities(v *MarkdownClientCapabilities) FinalizedMarkdownClientCapabilities { +func resolveMarkdownClientCapabilities(v *MarkdownClientCapabilities) ResolvedMarkdownClientCapabilities { if v == nil { - return FinalizedMarkdownClientCapabilities{} + return ResolvedMarkdownClientCapabilities{} } - return FinalizedMarkdownClientCapabilities{ + return ResolvedMarkdownClientCapabilities{ Parser: v.Parser, Version: derefOr(v.Version), AllowedTags: derefOr(v.AllowedTags), } } -type FinalizedGeneralClientCapabilities struct { - StaleRequestSupport FinalizedStaleRequestSupportOptions - RegularExpressions FinalizedRegularExpressionsClientCapabilities - Markdown FinalizedMarkdownClientCapabilities +type ResolvedGeneralClientCapabilities struct { + StaleRequestSupport ResolvedStaleRequestSupportOptions + RegularExpressions ResolvedRegularExpressionsClientCapabilities + Markdown ResolvedMarkdownClientCapabilities PositionEncodings []PositionEncodingKind } -func finalizeGeneralClientCapabilities(v *GeneralClientCapabilities) FinalizedGeneralClientCapabilities { +func resolveGeneralClientCapabilities(v *GeneralClientCapabilities) ResolvedGeneralClientCapabilities { if v == nil { - return FinalizedGeneralClientCapabilities{} + return ResolvedGeneralClientCapabilities{} } - return FinalizedGeneralClientCapabilities{ - StaleRequestSupport: finalizeStaleRequestSupportOptions(v.StaleRequestSupport), - RegularExpressions: finalizeRegularExpressionsClientCapabilities(v.RegularExpressions), - Markdown: finalizeMarkdownClientCapabilities(v.Markdown), + return ResolvedGeneralClientCapabilities{ + StaleRequestSupport: resolveStaleRequestSupportOptions(v.StaleRequestSupport), + RegularExpressions: resolveRegularExpressionsClientCapabilities(v.RegularExpressions), + Markdown: resolveMarkdownClientCapabilities(v.Markdown), PositionEncodings: derefOr(v.PositionEncodings), } } -// FinalizedClientCapabilities is a version of ClientCapabilities where all nested +// ResolvedClientCapabilities is a version of ClientCapabilities where all nested // fields are values (not pointers), making it easier to access deeply nested capabilities. -// Use FinalizeClientCapabilities to convert from ClientCapabilities. -type FinalizedClientCapabilities struct { - Workspace FinalizedWorkspaceClientCapabilities - TextDocument FinalizedTextDocumentClientCapabilities - NotebookDocument FinalizedNotebookDocumentClientCapabilities - Window FinalizedWindowClientCapabilities - General FinalizedGeneralClientCapabilities +// Use ResolveClientCapabilities to convert from ClientCapabilities. +type ResolvedClientCapabilities struct { + Workspace ResolvedWorkspaceClientCapabilities + TextDocument ResolvedTextDocumentClientCapabilities + NotebookDocument ResolvedNotebookDocumentClientCapabilities + Window ResolvedWindowClientCapabilities + General ResolvedGeneralClientCapabilities Experimental any } -func FinalizeClientCapabilities(v *ClientCapabilities) FinalizedClientCapabilities { +func ResolveClientCapabilities(v *ClientCapabilities) ResolvedClientCapabilities { if v == nil { - return FinalizedClientCapabilities{} - } - return FinalizedClientCapabilities{ - Workspace: finalizeWorkspaceClientCapabilities(v.Workspace), - TextDocument: finalizeTextDocumentClientCapabilities(v.TextDocument), - NotebookDocument: finalizeNotebookDocumentClientCapabilities(v.NotebookDocument), - Window: finalizeWindowClientCapabilities(v.Window), - General: finalizeGeneralClientCapabilities(v.General), + return ResolvedClientCapabilities{} + } + return ResolvedClientCapabilities{ + Workspace: resolveWorkspaceClientCapabilities(v.Workspace), + TextDocument: resolveTextDocumentClientCapabilities(v.TextDocument), + NotebookDocument: resolveNotebookDocumentClientCapabilities(v.NotebookDocument), + Window: resolveWindowClientCapabilities(v.Window), + General: resolveGeneralClientCapabilities(v.General), Experimental: derefOr(v.Experimental), } } diff --git a/internal/lsp/server.go b/internal/lsp/server.go index 0a283d7415..923888e7da 100644 --- a/internal/lsp/server.go +++ b/internal/lsp/server.go @@ -144,7 +144,7 @@ type Server struct { typingsLocation string initializeParams *lsproto.InitializeParams - clientCapabilities lsproto.FinalizedClientCapabilities + clientCapabilities lsproto.ResolvedClientCapabilities positionEncoding lsproto.PositionEncodingKind locale language.Tag @@ -585,7 +585,7 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ } s.initializeParams = params - s.clientCapabilities = finalizeClientCapabilities(params.Capabilities) + s.clientCapabilities = resolveClientCapabilities(params.Capabilities) s.positionEncoding = lsproto.PositionEncodingKindUTF16 if slices.Contains(s.clientCapabilities.General.PositionEncodings, lsproto.PositionEncodingKindUTF8) { @@ -968,16 +968,16 @@ func ptrTo[T any](v T) *T { return &v } -func finalizeClientCapabilities(caps *lsproto.ClientCapabilities) lsproto.FinalizedClientCapabilities { - finalized := lsproto.FinalizeClientCapabilities(caps) +func resolveClientCapabilities(caps *lsproto.ClientCapabilities) lsproto.ResolvedClientCapabilities { + resolved := lsproto.ResolveClientCapabilities(caps) // Some clients claim that push and pull diagnostics have different capabilities, // including vscode-languageclient v9. Work around this by defaulting any missing // pull diagnostic caps with the pull diagnostic equivalents. // // TODO: remove when we upgrade to vscode-languageclient v10, which fixes this issue. - publish := finalized.TextDocument.PublishDiagnostics - diagnostic := &finalized.TextDocument.Diagnostic + publish := resolved.TextDocument.PublishDiagnostics + diagnostic := &resolved.TextDocument.Diagnostic if !diagnostic.RelatedInformation && publish.RelatedInformation { diagnostic.RelatedInformation = true } @@ -991,5 +991,5 @@ func finalizeClientCapabilities(caps *lsproto.ClientCapabilities) lsproto.Finali diagnostic.TagSupport.ValueSet = publish.TagSupport.ValueSet } - return finalized + return resolved } From 0c4947a5cb748628988a6e0646207681e1ebb933 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 13:48:18 -0800 Subject: [PATCH 6/8] fmt --- internal/ls/signaturehelp.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/ls/signaturehelp.go b/internal/ls/signaturehelp.go index 6a4289b28b..4369ef0bc8 100644 --- a/internal/ls/signaturehelp.go +++ b/internal/ls/signaturehelp.go @@ -199,7 +199,7 @@ func getTypeHelpItem(symbol *ast.Symbol, typeParameter []*checker.Type, enclosin } } -func (l *LanguageService) createSignatureHelpItems(ctx context.Context,candidates []*checker.Signature, resolvedSignature *checker.Signature, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker, useFullPrefix bool) *lsproto.SignatureHelp { +func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidates []*checker.Signature, resolvedSignature *checker.Signature, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker, useFullPrefix bool) *lsproto.SignatureHelp { caps := lsproto.GetClientCapabilities(ctx) docFormat := lsproto.PreferredMarkupKind(caps.TextDocument.SignatureHelp.SignatureInformation.DocumentationFormat) From 910304349f1f91bdf080217a8d34400cdd9075ed Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 13:51:50 -0800 Subject: [PATCH 7/8] Add JSON tags --- internal/lsp/lsproto/_generate/generate.mts | 4 +- internal/lsp/lsproto/lsp_generated.go | 452 ++++++++++---------- 2 files changed, 228 insertions(+), 228 deletions(-) diff --git a/internal/lsp/lsproto/_generate/generate.mts b/internal/lsp/lsproto/_generate/generate.mts index d690782e0b..68bfb5778e 100644 --- a/internal/lsp/lsproto/_generate/generate.mts +++ b/internal/lsp/lsproto/_generate/generate.mts @@ -483,14 +483,14 @@ function generateCode() { const refStructure = model.structures.find(s => s.name === type.name); if (refStructure) { // Use a named type for the resolved version - lines.push(`${indent}${titleCase(prop.name)} Resolved${type.name}`); + lines.push(`${indent}${titleCase(prop.name)} Resolved${type.name} \`json:"${prop.name},omitzero"\``); continue; } } // For other types (primitives, enums, arrays, etc.), use the type directly (no pointer) const goType = type.name; - lines.push(`${indent}${titleCase(prop.name)} ${goType}`); + lines.push(`${indent}${titleCase(prop.name)} ${goType} \`json:"${prop.name},omitzero"\``); } return lines; diff --git a/internal/lsp/lsproto/lsp_generated.go b/internal/lsp/lsproto/lsp_generated.go index f7589a45cb..075d574c00 100644 --- a/internal/lsp/lsproto/lsp_generated.go +++ b/internal/lsp/lsproto/lsp_generated.go @@ -25736,7 +25736,7 @@ func derefOr[T any](v *T) T { } type ResolvedChangeAnnotationsSupportOptions struct { - GroupsOnLabel bool + GroupsOnLabel bool `json:"groupsOnLabel,omitzero"` } func resolveChangeAnnotationsSupportOptions(v *ChangeAnnotationsSupportOptions) ResolvedChangeAnnotationsSupportOptions { @@ -25749,13 +25749,13 @@ func resolveChangeAnnotationsSupportOptions(v *ChangeAnnotationsSupportOptions) } type ResolvedWorkspaceEditClientCapabilities struct { - DocumentChanges bool - ResourceOperations []ResourceOperationKind - FailureHandling FailureHandlingKind - NormalizesLineEndings bool - ChangeAnnotationSupport ResolvedChangeAnnotationsSupportOptions - MetadataSupport bool - SnippetEditSupport bool + DocumentChanges bool `json:"documentChanges,omitzero"` + ResourceOperations []ResourceOperationKind `json:"resourceOperations,omitzero"` + FailureHandling FailureHandlingKind `json:"failureHandling,omitzero"` + NormalizesLineEndings bool `json:"normalizesLineEndings,omitzero"` + ChangeAnnotationSupport ResolvedChangeAnnotationsSupportOptions `json:"changeAnnotationSupport,omitzero"` + MetadataSupport bool `json:"metadataSupport,omitzero"` + SnippetEditSupport bool `json:"snippetEditSupport,omitzero"` } func resolveWorkspaceEditClientCapabilities(v *WorkspaceEditClientCapabilities) ResolvedWorkspaceEditClientCapabilities { @@ -25774,7 +25774,7 @@ func resolveWorkspaceEditClientCapabilities(v *WorkspaceEditClientCapabilities) } type ResolvedDidChangeConfigurationClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveDidChangeConfigurationClientCapabilities(v *DidChangeConfigurationClientCapabilities) ResolvedDidChangeConfigurationClientCapabilities { @@ -25787,8 +25787,8 @@ func resolveDidChangeConfigurationClientCapabilities(v *DidChangeConfigurationCl } type ResolvedDidChangeWatchedFilesClientCapabilities struct { - DynamicRegistration bool - RelativePatternSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + RelativePatternSupport bool `json:"relativePatternSupport,omitzero"` } func resolveDidChangeWatchedFilesClientCapabilities(v *DidChangeWatchedFilesClientCapabilities) ResolvedDidChangeWatchedFilesClientCapabilities { @@ -25802,7 +25802,7 @@ func resolveDidChangeWatchedFilesClientCapabilities(v *DidChangeWatchedFilesClie } type ResolvedClientSymbolKindOptions struct { - ValueSet []SymbolKind + ValueSet []SymbolKind `json:"valueSet,omitzero"` } func resolveClientSymbolKindOptions(v *ClientSymbolKindOptions) ResolvedClientSymbolKindOptions { @@ -25815,7 +25815,7 @@ func resolveClientSymbolKindOptions(v *ClientSymbolKindOptions) ResolvedClientSy } type ResolvedClientSymbolTagOptions struct { - ValueSet []SymbolTag + ValueSet []SymbolTag `json:"valueSet,omitzero"` } func resolveClientSymbolTagOptions(v *ClientSymbolTagOptions) ResolvedClientSymbolTagOptions { @@ -25828,7 +25828,7 @@ func resolveClientSymbolTagOptions(v *ClientSymbolTagOptions) ResolvedClientSymb } type ResolvedClientSymbolResolveOptions struct { - Properties []string + Properties []string `json:"properties,omitzero"` } func resolveClientSymbolResolveOptions(v *ClientSymbolResolveOptions) ResolvedClientSymbolResolveOptions { @@ -25841,10 +25841,10 @@ func resolveClientSymbolResolveOptions(v *ClientSymbolResolveOptions) ResolvedCl } type ResolvedWorkspaceSymbolClientCapabilities struct { - DynamicRegistration bool - SymbolKind ResolvedClientSymbolKindOptions - TagSupport ResolvedClientSymbolTagOptions - ResolveSupport ResolvedClientSymbolResolveOptions + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + SymbolKind ResolvedClientSymbolKindOptions `json:"symbolKind,omitzero"` + TagSupport ResolvedClientSymbolTagOptions `json:"tagSupport,omitzero"` + ResolveSupport ResolvedClientSymbolResolveOptions `json:"resolveSupport,omitzero"` } func resolveWorkspaceSymbolClientCapabilities(v *WorkspaceSymbolClientCapabilities) ResolvedWorkspaceSymbolClientCapabilities { @@ -25860,7 +25860,7 @@ func resolveWorkspaceSymbolClientCapabilities(v *WorkspaceSymbolClientCapabiliti } type ResolvedExecuteCommandClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveExecuteCommandClientCapabilities(v *ExecuteCommandClientCapabilities) ResolvedExecuteCommandClientCapabilities { @@ -25873,7 +25873,7 @@ func resolveExecuteCommandClientCapabilities(v *ExecuteCommandClientCapabilities } type ResolvedSemanticTokensWorkspaceClientCapabilities struct { - RefreshSupport bool + RefreshSupport bool `json:"refreshSupport,omitzero"` } func resolveSemanticTokensWorkspaceClientCapabilities(v *SemanticTokensWorkspaceClientCapabilities) ResolvedSemanticTokensWorkspaceClientCapabilities { @@ -25886,7 +25886,7 @@ func resolveSemanticTokensWorkspaceClientCapabilities(v *SemanticTokensWorkspace } type ResolvedCodeLensWorkspaceClientCapabilities struct { - RefreshSupport bool + RefreshSupport bool `json:"refreshSupport,omitzero"` } func resolveCodeLensWorkspaceClientCapabilities(v *CodeLensWorkspaceClientCapabilities) ResolvedCodeLensWorkspaceClientCapabilities { @@ -25899,13 +25899,13 @@ func resolveCodeLensWorkspaceClientCapabilities(v *CodeLensWorkspaceClientCapabi } type ResolvedFileOperationClientCapabilities struct { - DynamicRegistration bool - DidCreate bool - WillCreate bool - DidRename bool - WillRename bool - DidDelete bool - WillDelete bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + DidCreate bool `json:"didCreate,omitzero"` + WillCreate bool `json:"willCreate,omitzero"` + DidRename bool `json:"didRename,omitzero"` + WillRename bool `json:"willRename,omitzero"` + DidDelete bool `json:"didDelete,omitzero"` + WillDelete bool `json:"willDelete,omitzero"` } func resolveFileOperationClientCapabilities(v *FileOperationClientCapabilities) ResolvedFileOperationClientCapabilities { @@ -25924,7 +25924,7 @@ func resolveFileOperationClientCapabilities(v *FileOperationClientCapabilities) } type ResolvedInlineValueWorkspaceClientCapabilities struct { - RefreshSupport bool + RefreshSupport bool `json:"refreshSupport,omitzero"` } func resolveInlineValueWorkspaceClientCapabilities(v *InlineValueWorkspaceClientCapabilities) ResolvedInlineValueWorkspaceClientCapabilities { @@ -25937,7 +25937,7 @@ func resolveInlineValueWorkspaceClientCapabilities(v *InlineValueWorkspaceClient } type ResolvedInlayHintWorkspaceClientCapabilities struct { - RefreshSupport bool + RefreshSupport bool `json:"refreshSupport,omitzero"` } func resolveInlayHintWorkspaceClientCapabilities(v *InlayHintWorkspaceClientCapabilities) ResolvedInlayHintWorkspaceClientCapabilities { @@ -25950,7 +25950,7 @@ func resolveInlayHintWorkspaceClientCapabilities(v *InlayHintWorkspaceClientCapa } type ResolvedDiagnosticWorkspaceClientCapabilities struct { - RefreshSupport bool + RefreshSupport bool `json:"refreshSupport,omitzero"` } func resolveDiagnosticWorkspaceClientCapabilities(v *DiagnosticWorkspaceClientCapabilities) ResolvedDiagnosticWorkspaceClientCapabilities { @@ -25963,7 +25963,7 @@ func resolveDiagnosticWorkspaceClientCapabilities(v *DiagnosticWorkspaceClientCa } type ResolvedFoldingRangeWorkspaceClientCapabilities struct { - RefreshSupport bool + RefreshSupport bool `json:"refreshSupport,omitzero"` } func resolveFoldingRangeWorkspaceClientCapabilities(v *FoldingRangeWorkspaceClientCapabilities) ResolvedFoldingRangeWorkspaceClientCapabilities { @@ -25976,7 +25976,7 @@ func resolveFoldingRangeWorkspaceClientCapabilities(v *FoldingRangeWorkspaceClie } type ResolvedTextDocumentContentClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveTextDocumentContentClientCapabilities(v *TextDocumentContentClientCapabilities) ResolvedTextDocumentContentClientCapabilities { @@ -25989,22 +25989,22 @@ func resolveTextDocumentContentClientCapabilities(v *TextDocumentContentClientCa } type ResolvedWorkspaceClientCapabilities struct { - ApplyEdit bool - WorkspaceEdit ResolvedWorkspaceEditClientCapabilities - DidChangeConfiguration ResolvedDidChangeConfigurationClientCapabilities - DidChangeWatchedFiles ResolvedDidChangeWatchedFilesClientCapabilities - Symbol ResolvedWorkspaceSymbolClientCapabilities - ExecuteCommand ResolvedExecuteCommandClientCapabilities - WorkspaceFolders bool - Configuration bool - SemanticTokens ResolvedSemanticTokensWorkspaceClientCapabilities - CodeLens ResolvedCodeLensWorkspaceClientCapabilities - FileOperations ResolvedFileOperationClientCapabilities - InlineValue ResolvedInlineValueWorkspaceClientCapabilities - InlayHint ResolvedInlayHintWorkspaceClientCapabilities - Diagnostics ResolvedDiagnosticWorkspaceClientCapabilities - FoldingRange ResolvedFoldingRangeWorkspaceClientCapabilities - TextDocumentContent ResolvedTextDocumentContentClientCapabilities + ApplyEdit bool `json:"applyEdit,omitzero"` + WorkspaceEdit ResolvedWorkspaceEditClientCapabilities `json:"workspaceEdit,omitzero"` + DidChangeConfiguration ResolvedDidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitzero"` + DidChangeWatchedFiles ResolvedDidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitzero"` + Symbol ResolvedWorkspaceSymbolClientCapabilities `json:"symbol,omitzero"` + ExecuteCommand ResolvedExecuteCommandClientCapabilities `json:"executeCommand,omitzero"` + WorkspaceFolders bool `json:"workspaceFolders,omitzero"` + Configuration bool `json:"configuration,omitzero"` + SemanticTokens ResolvedSemanticTokensWorkspaceClientCapabilities `json:"semanticTokens,omitzero"` + CodeLens ResolvedCodeLensWorkspaceClientCapabilities `json:"codeLens,omitzero"` + FileOperations ResolvedFileOperationClientCapabilities `json:"fileOperations,omitzero"` + InlineValue ResolvedInlineValueWorkspaceClientCapabilities `json:"inlineValue,omitzero"` + InlayHint ResolvedInlayHintWorkspaceClientCapabilities `json:"inlayHint,omitzero"` + Diagnostics ResolvedDiagnosticWorkspaceClientCapabilities `json:"diagnostics,omitzero"` + FoldingRange ResolvedFoldingRangeWorkspaceClientCapabilities `json:"foldingRange,omitzero"` + TextDocumentContent ResolvedTextDocumentContentClientCapabilities `json:"textDocumentContent,omitzero"` } func resolveWorkspaceClientCapabilities(v *WorkspaceClientCapabilities) ResolvedWorkspaceClientCapabilities { @@ -26032,10 +26032,10 @@ func resolveWorkspaceClientCapabilities(v *WorkspaceClientCapabilities) Resolved } type ResolvedTextDocumentSyncClientCapabilities struct { - DynamicRegistration bool - WillSave bool - WillSaveWaitUntil bool - DidSave bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + WillSave bool `json:"willSave,omitzero"` + WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitzero"` + DidSave bool `json:"didSave,omitzero"` } func resolveTextDocumentSyncClientCapabilities(v *TextDocumentSyncClientCapabilities) ResolvedTextDocumentSyncClientCapabilities { @@ -26051,7 +26051,7 @@ func resolveTextDocumentSyncClientCapabilities(v *TextDocumentSyncClientCapabili } type ResolvedTextDocumentFilterClientCapabilities struct { - RelativePatternSupport bool + RelativePatternSupport bool `json:"relativePatternSupport,omitzero"` } func resolveTextDocumentFilterClientCapabilities(v *TextDocumentFilterClientCapabilities) ResolvedTextDocumentFilterClientCapabilities { @@ -26064,7 +26064,7 @@ func resolveTextDocumentFilterClientCapabilities(v *TextDocumentFilterClientCapa } type ResolvedCompletionItemTagOptions struct { - ValueSet []CompletionItemTag + ValueSet []CompletionItemTag `json:"valueSet,omitzero"` } func resolveCompletionItemTagOptions(v *CompletionItemTagOptions) ResolvedCompletionItemTagOptions { @@ -26077,7 +26077,7 @@ func resolveCompletionItemTagOptions(v *CompletionItemTagOptions) ResolvedComple } type ResolvedClientCompletionItemResolveOptions struct { - Properties []string + Properties []string `json:"properties,omitzero"` } func resolveClientCompletionItemResolveOptions(v *ClientCompletionItemResolveOptions) ResolvedClientCompletionItemResolveOptions { @@ -26090,7 +26090,7 @@ func resolveClientCompletionItemResolveOptions(v *ClientCompletionItemResolveOpt } type ResolvedClientCompletionItemInsertTextModeOptions struct { - ValueSet []InsertTextMode + ValueSet []InsertTextMode `json:"valueSet,omitzero"` } func resolveClientCompletionItemInsertTextModeOptions(v *ClientCompletionItemInsertTextModeOptions) ResolvedClientCompletionItemInsertTextModeOptions { @@ -26103,16 +26103,16 @@ func resolveClientCompletionItemInsertTextModeOptions(v *ClientCompletionItemIns } type ResolvedClientCompletionItemOptions struct { - SnippetSupport bool - CommitCharactersSupport bool - DocumentationFormat []MarkupKind - DeprecatedSupport bool - PreselectSupport bool - TagSupport ResolvedCompletionItemTagOptions - InsertReplaceSupport bool - ResolveSupport ResolvedClientCompletionItemResolveOptions - InsertTextModeSupport ResolvedClientCompletionItemInsertTextModeOptions - LabelDetailsSupport bool + SnippetSupport bool `json:"snippetSupport,omitzero"` + CommitCharactersSupport bool `json:"commitCharactersSupport,omitzero"` + DocumentationFormat []MarkupKind `json:"documentationFormat,omitzero"` + DeprecatedSupport bool `json:"deprecatedSupport,omitzero"` + PreselectSupport bool `json:"preselectSupport,omitzero"` + TagSupport ResolvedCompletionItemTagOptions `json:"tagSupport,omitzero"` + InsertReplaceSupport bool `json:"insertReplaceSupport,omitzero"` + ResolveSupport ResolvedClientCompletionItemResolveOptions `json:"resolveSupport,omitzero"` + InsertTextModeSupport ResolvedClientCompletionItemInsertTextModeOptions `json:"insertTextModeSupport,omitzero"` + LabelDetailsSupport bool `json:"labelDetailsSupport,omitzero"` } func resolveClientCompletionItemOptions(v *ClientCompletionItemOptions) ResolvedClientCompletionItemOptions { @@ -26134,7 +26134,7 @@ func resolveClientCompletionItemOptions(v *ClientCompletionItemOptions) Resolved } type ResolvedClientCompletionItemOptionsKind struct { - ValueSet []CompletionItemKind + ValueSet []CompletionItemKind `json:"valueSet,omitzero"` } func resolveClientCompletionItemOptionsKind(v *ClientCompletionItemOptionsKind) ResolvedClientCompletionItemOptionsKind { @@ -26147,8 +26147,8 @@ func resolveClientCompletionItemOptionsKind(v *ClientCompletionItemOptionsKind) } type ResolvedCompletionListCapabilities struct { - ItemDefaults []string - ApplyKindSupport bool + ItemDefaults []string `json:"itemDefaults,omitzero"` + ApplyKindSupport bool `json:"applyKindSupport,omitzero"` } func resolveCompletionListCapabilities(v *CompletionListCapabilities) ResolvedCompletionListCapabilities { @@ -26162,12 +26162,12 @@ func resolveCompletionListCapabilities(v *CompletionListCapabilities) ResolvedCo } type ResolvedCompletionClientCapabilities struct { - DynamicRegistration bool - CompletionItem ResolvedClientCompletionItemOptions - CompletionItemKind ResolvedClientCompletionItemOptionsKind - InsertTextMode InsertTextMode - ContextSupport bool - CompletionList ResolvedCompletionListCapabilities + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + CompletionItem ResolvedClientCompletionItemOptions `json:"completionItem,omitzero"` + CompletionItemKind ResolvedClientCompletionItemOptionsKind `json:"completionItemKind,omitzero"` + InsertTextMode InsertTextMode `json:"insertTextMode,omitzero"` + ContextSupport bool `json:"contextSupport,omitzero"` + CompletionList ResolvedCompletionListCapabilities `json:"completionList,omitzero"` } func resolveCompletionClientCapabilities(v *CompletionClientCapabilities) ResolvedCompletionClientCapabilities { @@ -26185,8 +26185,8 @@ func resolveCompletionClientCapabilities(v *CompletionClientCapabilities) Resolv } type ResolvedHoverClientCapabilities struct { - DynamicRegistration bool - ContentFormat []MarkupKind + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + ContentFormat []MarkupKind `json:"contentFormat,omitzero"` } func resolveHoverClientCapabilities(v *HoverClientCapabilities) ResolvedHoverClientCapabilities { @@ -26200,7 +26200,7 @@ func resolveHoverClientCapabilities(v *HoverClientCapabilities) ResolvedHoverCli } type ResolvedClientSignatureParameterInformationOptions struct { - LabelOffsetSupport bool + LabelOffsetSupport bool `json:"labelOffsetSupport,omitzero"` } func resolveClientSignatureParameterInformationOptions(v *ClientSignatureParameterInformationOptions) ResolvedClientSignatureParameterInformationOptions { @@ -26213,10 +26213,10 @@ func resolveClientSignatureParameterInformationOptions(v *ClientSignatureParamet } type ResolvedClientSignatureInformationOptions struct { - DocumentationFormat []MarkupKind - ParameterInformation ResolvedClientSignatureParameterInformationOptions - ActiveParameterSupport bool - NoActiveParameterSupport bool + DocumentationFormat []MarkupKind `json:"documentationFormat,omitzero"` + ParameterInformation ResolvedClientSignatureParameterInformationOptions `json:"parameterInformation,omitzero"` + ActiveParameterSupport bool `json:"activeParameterSupport,omitzero"` + NoActiveParameterSupport bool `json:"noActiveParameterSupport,omitzero"` } func resolveClientSignatureInformationOptions(v *ClientSignatureInformationOptions) ResolvedClientSignatureInformationOptions { @@ -26232,9 +26232,9 @@ func resolveClientSignatureInformationOptions(v *ClientSignatureInformationOptio } type ResolvedSignatureHelpClientCapabilities struct { - DynamicRegistration bool - SignatureInformation ResolvedClientSignatureInformationOptions - ContextSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + SignatureInformation ResolvedClientSignatureInformationOptions `json:"signatureInformation,omitzero"` + ContextSupport bool `json:"contextSupport,omitzero"` } func resolveSignatureHelpClientCapabilities(v *SignatureHelpClientCapabilities) ResolvedSignatureHelpClientCapabilities { @@ -26249,8 +26249,8 @@ func resolveSignatureHelpClientCapabilities(v *SignatureHelpClientCapabilities) } type ResolvedDeclarationClientCapabilities struct { - DynamicRegistration bool - LinkSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + LinkSupport bool `json:"linkSupport,omitzero"` } func resolveDeclarationClientCapabilities(v *DeclarationClientCapabilities) ResolvedDeclarationClientCapabilities { @@ -26264,8 +26264,8 @@ func resolveDeclarationClientCapabilities(v *DeclarationClientCapabilities) Reso } type ResolvedDefinitionClientCapabilities struct { - DynamicRegistration bool - LinkSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + LinkSupport bool `json:"linkSupport,omitzero"` } func resolveDefinitionClientCapabilities(v *DefinitionClientCapabilities) ResolvedDefinitionClientCapabilities { @@ -26279,8 +26279,8 @@ func resolveDefinitionClientCapabilities(v *DefinitionClientCapabilities) Resolv } type ResolvedTypeDefinitionClientCapabilities struct { - DynamicRegistration bool - LinkSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + LinkSupport bool `json:"linkSupport,omitzero"` } func resolveTypeDefinitionClientCapabilities(v *TypeDefinitionClientCapabilities) ResolvedTypeDefinitionClientCapabilities { @@ -26294,8 +26294,8 @@ func resolveTypeDefinitionClientCapabilities(v *TypeDefinitionClientCapabilities } type ResolvedImplementationClientCapabilities struct { - DynamicRegistration bool - LinkSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + LinkSupport bool `json:"linkSupport,omitzero"` } func resolveImplementationClientCapabilities(v *ImplementationClientCapabilities) ResolvedImplementationClientCapabilities { @@ -26309,7 +26309,7 @@ func resolveImplementationClientCapabilities(v *ImplementationClientCapabilities } type ResolvedReferenceClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveReferenceClientCapabilities(v *ReferenceClientCapabilities) ResolvedReferenceClientCapabilities { @@ -26322,7 +26322,7 @@ func resolveReferenceClientCapabilities(v *ReferenceClientCapabilities) Resolved } type ResolvedDocumentHighlightClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveDocumentHighlightClientCapabilities(v *DocumentHighlightClientCapabilities) ResolvedDocumentHighlightClientCapabilities { @@ -26335,11 +26335,11 @@ func resolveDocumentHighlightClientCapabilities(v *DocumentHighlightClientCapabi } type ResolvedDocumentSymbolClientCapabilities struct { - DynamicRegistration bool - SymbolKind ResolvedClientSymbolKindOptions - HierarchicalDocumentSymbolSupport bool - TagSupport ResolvedClientSymbolTagOptions - LabelSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + SymbolKind ResolvedClientSymbolKindOptions `json:"symbolKind,omitzero"` + HierarchicalDocumentSymbolSupport bool `json:"hierarchicalDocumentSymbolSupport,omitzero"` + TagSupport ResolvedClientSymbolTagOptions `json:"tagSupport,omitzero"` + LabelSupport bool `json:"labelSupport,omitzero"` } func resolveDocumentSymbolClientCapabilities(v *DocumentSymbolClientCapabilities) ResolvedDocumentSymbolClientCapabilities { @@ -26356,7 +26356,7 @@ func resolveDocumentSymbolClientCapabilities(v *DocumentSymbolClientCapabilities } type ResolvedClientCodeActionKindOptions struct { - ValueSet []CodeActionKind + ValueSet []CodeActionKind `json:"valueSet,omitzero"` } func resolveClientCodeActionKindOptions(v *ClientCodeActionKindOptions) ResolvedClientCodeActionKindOptions { @@ -26369,7 +26369,7 @@ func resolveClientCodeActionKindOptions(v *ClientCodeActionKindOptions) Resolved } type ResolvedClientCodeActionLiteralOptions struct { - CodeActionKind ResolvedClientCodeActionKindOptions + CodeActionKind ResolvedClientCodeActionKindOptions `json:"codeActionKind,omitzero"` } func resolveClientCodeActionLiteralOptions(v *ClientCodeActionLiteralOptions) ResolvedClientCodeActionLiteralOptions { @@ -26382,7 +26382,7 @@ func resolveClientCodeActionLiteralOptions(v *ClientCodeActionLiteralOptions) Re } type ResolvedClientCodeActionResolveOptions struct { - Properties []string + Properties []string `json:"properties,omitzero"` } func resolveClientCodeActionResolveOptions(v *ClientCodeActionResolveOptions) ResolvedClientCodeActionResolveOptions { @@ -26395,7 +26395,7 @@ func resolveClientCodeActionResolveOptions(v *ClientCodeActionResolveOptions) Re } type ResolvedCodeActionTagOptions struct { - ValueSet []CodeActionTag + ValueSet []CodeActionTag `json:"valueSet,omitzero"` } func resolveCodeActionTagOptions(v *CodeActionTagOptions) ResolvedCodeActionTagOptions { @@ -26408,15 +26408,15 @@ func resolveCodeActionTagOptions(v *CodeActionTagOptions) ResolvedCodeActionTagO } type ResolvedCodeActionClientCapabilities struct { - DynamicRegistration bool - CodeActionLiteralSupport ResolvedClientCodeActionLiteralOptions - IsPreferredSupport bool - DisabledSupport bool - DataSupport bool - ResolveSupport ResolvedClientCodeActionResolveOptions - HonorsChangeAnnotations bool - DocumentationSupport bool - TagSupport ResolvedCodeActionTagOptions + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + CodeActionLiteralSupport ResolvedClientCodeActionLiteralOptions `json:"codeActionLiteralSupport,omitzero"` + IsPreferredSupport bool `json:"isPreferredSupport,omitzero"` + DisabledSupport bool `json:"disabledSupport,omitzero"` + DataSupport bool `json:"dataSupport,omitzero"` + ResolveSupport ResolvedClientCodeActionResolveOptions `json:"resolveSupport,omitzero"` + HonorsChangeAnnotations bool `json:"honorsChangeAnnotations,omitzero"` + DocumentationSupport bool `json:"documentationSupport,omitzero"` + TagSupport ResolvedCodeActionTagOptions `json:"tagSupport,omitzero"` } func resolveCodeActionClientCapabilities(v *CodeActionClientCapabilities) ResolvedCodeActionClientCapabilities { @@ -26437,7 +26437,7 @@ func resolveCodeActionClientCapabilities(v *CodeActionClientCapabilities) Resolv } type ResolvedClientCodeLensResolveOptions struct { - Properties []string + Properties []string `json:"properties,omitzero"` } func resolveClientCodeLensResolveOptions(v *ClientCodeLensResolveOptions) ResolvedClientCodeLensResolveOptions { @@ -26450,8 +26450,8 @@ func resolveClientCodeLensResolveOptions(v *ClientCodeLensResolveOptions) Resolv } type ResolvedCodeLensClientCapabilities struct { - DynamicRegistration bool - ResolveSupport ResolvedClientCodeLensResolveOptions + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + ResolveSupport ResolvedClientCodeLensResolveOptions `json:"resolveSupport,omitzero"` } func resolveCodeLensClientCapabilities(v *CodeLensClientCapabilities) ResolvedCodeLensClientCapabilities { @@ -26465,8 +26465,8 @@ func resolveCodeLensClientCapabilities(v *CodeLensClientCapabilities) ResolvedCo } type ResolvedDocumentLinkClientCapabilities struct { - DynamicRegistration bool - TooltipSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + TooltipSupport bool `json:"tooltipSupport,omitzero"` } func resolveDocumentLinkClientCapabilities(v *DocumentLinkClientCapabilities) ResolvedDocumentLinkClientCapabilities { @@ -26480,7 +26480,7 @@ func resolveDocumentLinkClientCapabilities(v *DocumentLinkClientCapabilities) Re } type ResolvedDocumentColorClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveDocumentColorClientCapabilities(v *DocumentColorClientCapabilities) ResolvedDocumentColorClientCapabilities { @@ -26493,7 +26493,7 @@ func resolveDocumentColorClientCapabilities(v *DocumentColorClientCapabilities) } type ResolvedDocumentFormattingClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveDocumentFormattingClientCapabilities(v *DocumentFormattingClientCapabilities) ResolvedDocumentFormattingClientCapabilities { @@ -26506,8 +26506,8 @@ func resolveDocumentFormattingClientCapabilities(v *DocumentFormattingClientCapa } type ResolvedDocumentRangeFormattingClientCapabilities struct { - DynamicRegistration bool - RangesSupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + RangesSupport bool `json:"rangesSupport,omitzero"` } func resolveDocumentRangeFormattingClientCapabilities(v *DocumentRangeFormattingClientCapabilities) ResolvedDocumentRangeFormattingClientCapabilities { @@ -26521,7 +26521,7 @@ func resolveDocumentRangeFormattingClientCapabilities(v *DocumentRangeFormatting } type ResolvedDocumentOnTypeFormattingClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveDocumentOnTypeFormattingClientCapabilities(v *DocumentOnTypeFormattingClientCapabilities) ResolvedDocumentOnTypeFormattingClientCapabilities { @@ -26534,10 +26534,10 @@ func resolveDocumentOnTypeFormattingClientCapabilities(v *DocumentOnTypeFormatti } type ResolvedRenameClientCapabilities struct { - DynamicRegistration bool - PrepareSupport bool - PrepareSupportDefaultBehavior PrepareSupportDefaultBehavior - HonorsChangeAnnotations bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + PrepareSupport bool `json:"prepareSupport,omitzero"` + PrepareSupportDefaultBehavior PrepareSupportDefaultBehavior `json:"prepareSupportDefaultBehavior,omitzero"` + HonorsChangeAnnotations bool `json:"honorsChangeAnnotations,omitzero"` } func resolveRenameClientCapabilities(v *RenameClientCapabilities) ResolvedRenameClientCapabilities { @@ -26553,7 +26553,7 @@ func resolveRenameClientCapabilities(v *RenameClientCapabilities) ResolvedRename } type ResolvedClientFoldingRangeKindOptions struct { - ValueSet []FoldingRangeKind + ValueSet []FoldingRangeKind `json:"valueSet,omitzero"` } func resolveClientFoldingRangeKindOptions(v *ClientFoldingRangeKindOptions) ResolvedClientFoldingRangeKindOptions { @@ -26566,7 +26566,7 @@ func resolveClientFoldingRangeKindOptions(v *ClientFoldingRangeKindOptions) Reso } type ResolvedClientFoldingRangeOptions struct { - CollapsedText bool + CollapsedText bool `json:"collapsedText,omitzero"` } func resolveClientFoldingRangeOptions(v *ClientFoldingRangeOptions) ResolvedClientFoldingRangeOptions { @@ -26579,11 +26579,11 @@ func resolveClientFoldingRangeOptions(v *ClientFoldingRangeOptions) ResolvedClie } type ResolvedFoldingRangeClientCapabilities struct { - DynamicRegistration bool - RangeLimit uint32 - LineFoldingOnly bool - FoldingRangeKind ResolvedClientFoldingRangeKindOptions - FoldingRange ResolvedClientFoldingRangeOptions + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + RangeLimit uint32 `json:"rangeLimit,omitzero"` + LineFoldingOnly bool `json:"lineFoldingOnly,omitzero"` + FoldingRangeKind ResolvedClientFoldingRangeKindOptions `json:"foldingRangeKind,omitzero"` + FoldingRange ResolvedClientFoldingRangeOptions `json:"foldingRange,omitzero"` } func resolveFoldingRangeClientCapabilities(v *FoldingRangeClientCapabilities) ResolvedFoldingRangeClientCapabilities { @@ -26600,7 +26600,7 @@ func resolveFoldingRangeClientCapabilities(v *FoldingRangeClientCapabilities) Re } type ResolvedSelectionRangeClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveSelectionRangeClientCapabilities(v *SelectionRangeClientCapabilities) ResolvedSelectionRangeClientCapabilities { @@ -26613,7 +26613,7 @@ func resolveSelectionRangeClientCapabilities(v *SelectionRangeClientCapabilities } type ResolvedClientDiagnosticsTagOptions struct { - ValueSet []DiagnosticTag + ValueSet []DiagnosticTag `json:"valueSet,omitzero"` } func resolveClientDiagnosticsTagOptions(v *ClientDiagnosticsTagOptions) ResolvedClientDiagnosticsTagOptions { @@ -26626,11 +26626,11 @@ func resolveClientDiagnosticsTagOptions(v *ClientDiagnosticsTagOptions) Resolved } type ResolvedPublishDiagnosticsClientCapabilities struct { - RelatedInformation bool - TagSupport ResolvedClientDiagnosticsTagOptions - CodeDescriptionSupport bool - DataSupport bool - VersionSupport bool + RelatedInformation bool `json:"relatedInformation,omitzero"` + TagSupport ResolvedClientDiagnosticsTagOptions `json:"tagSupport,omitzero"` + CodeDescriptionSupport bool `json:"codeDescriptionSupport,omitzero"` + DataSupport bool `json:"dataSupport,omitzero"` + VersionSupport bool `json:"versionSupport,omitzero"` } func resolvePublishDiagnosticsClientCapabilities(v *PublishDiagnosticsClientCapabilities) ResolvedPublishDiagnosticsClientCapabilities { @@ -26647,7 +26647,7 @@ func resolvePublishDiagnosticsClientCapabilities(v *PublishDiagnosticsClientCapa } type ResolvedCallHierarchyClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveCallHierarchyClientCapabilities(v *CallHierarchyClientCapabilities) ResolvedCallHierarchyClientCapabilities { @@ -26660,8 +26660,8 @@ func resolveCallHierarchyClientCapabilities(v *CallHierarchyClientCapabilities) } type ResolvedClientSemanticTokensRequestOptions struct { - Range BooleanOrEmptyObject - Full BooleanOrClientSemanticTokensRequestFullDelta + Range BooleanOrEmptyObject `json:"range,omitzero"` + Full BooleanOrClientSemanticTokensRequestFullDelta `json:"full,omitzero"` } func resolveClientSemanticTokensRequestOptions(v *ClientSemanticTokensRequestOptions) ResolvedClientSemanticTokensRequestOptions { @@ -26675,15 +26675,15 @@ func resolveClientSemanticTokensRequestOptions(v *ClientSemanticTokensRequestOpt } type ResolvedSemanticTokensClientCapabilities struct { - DynamicRegistration bool - Requests ResolvedClientSemanticTokensRequestOptions - TokenTypes []string - TokenModifiers []string - Formats []TokenFormat - OverlappingTokenSupport bool - MultilineTokenSupport bool - ServerCancelSupport bool - AugmentsSyntaxTokens bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + Requests ResolvedClientSemanticTokensRequestOptions `json:"requests,omitzero"` + TokenTypes []string `json:"tokenTypes,omitzero"` + TokenModifiers []string `json:"tokenModifiers,omitzero"` + Formats []TokenFormat `json:"formats,omitzero"` + OverlappingTokenSupport bool `json:"overlappingTokenSupport,omitzero"` + MultilineTokenSupport bool `json:"multilineTokenSupport,omitzero"` + ServerCancelSupport bool `json:"serverCancelSupport,omitzero"` + AugmentsSyntaxTokens bool `json:"augmentsSyntaxTokens,omitzero"` } func resolveSemanticTokensClientCapabilities(v *SemanticTokensClientCapabilities) ResolvedSemanticTokensClientCapabilities { @@ -26704,7 +26704,7 @@ func resolveSemanticTokensClientCapabilities(v *SemanticTokensClientCapabilities } type ResolvedLinkedEditingRangeClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveLinkedEditingRangeClientCapabilities(v *LinkedEditingRangeClientCapabilities) ResolvedLinkedEditingRangeClientCapabilities { @@ -26717,7 +26717,7 @@ func resolveLinkedEditingRangeClientCapabilities(v *LinkedEditingRangeClientCapa } type ResolvedMonikerClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveMonikerClientCapabilities(v *MonikerClientCapabilities) ResolvedMonikerClientCapabilities { @@ -26730,7 +26730,7 @@ func resolveMonikerClientCapabilities(v *MonikerClientCapabilities) ResolvedMoni } type ResolvedTypeHierarchyClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveTypeHierarchyClientCapabilities(v *TypeHierarchyClientCapabilities) ResolvedTypeHierarchyClientCapabilities { @@ -26743,7 +26743,7 @@ func resolveTypeHierarchyClientCapabilities(v *TypeHierarchyClientCapabilities) } type ResolvedInlineValueClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveInlineValueClientCapabilities(v *InlineValueClientCapabilities) ResolvedInlineValueClientCapabilities { @@ -26756,7 +26756,7 @@ func resolveInlineValueClientCapabilities(v *InlineValueClientCapabilities) Reso } type ResolvedClientInlayHintResolveOptions struct { - Properties []string + Properties []string `json:"properties,omitzero"` } func resolveClientInlayHintResolveOptions(v *ClientInlayHintResolveOptions) ResolvedClientInlayHintResolveOptions { @@ -26769,8 +26769,8 @@ func resolveClientInlayHintResolveOptions(v *ClientInlayHintResolveOptions) Reso } type ResolvedInlayHintClientCapabilities struct { - DynamicRegistration bool - ResolveSupport ResolvedClientInlayHintResolveOptions + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + ResolveSupport ResolvedClientInlayHintResolveOptions `json:"resolveSupport,omitzero"` } func resolveInlayHintClientCapabilities(v *InlayHintClientCapabilities) ResolvedInlayHintClientCapabilities { @@ -26784,12 +26784,12 @@ func resolveInlayHintClientCapabilities(v *InlayHintClientCapabilities) Resolved } type ResolvedDiagnosticClientCapabilities struct { - RelatedInformation bool - TagSupport ResolvedClientDiagnosticsTagOptions - CodeDescriptionSupport bool - DataSupport bool - DynamicRegistration bool - RelatedDocumentSupport bool + RelatedInformation bool `json:"relatedInformation,omitzero"` + TagSupport ResolvedClientDiagnosticsTagOptions `json:"tagSupport,omitzero"` + CodeDescriptionSupport bool `json:"codeDescriptionSupport,omitzero"` + DataSupport bool `json:"dataSupport,omitzero"` + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + RelatedDocumentSupport bool `json:"relatedDocumentSupport,omitzero"` } func resolveDiagnosticClientCapabilities(v *DiagnosticClientCapabilities) ResolvedDiagnosticClientCapabilities { @@ -26807,7 +26807,7 @@ func resolveDiagnosticClientCapabilities(v *DiagnosticClientCapabilities) Resolv } type ResolvedInlineCompletionClientCapabilities struct { - DynamicRegistration bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` } func resolveInlineCompletionClientCapabilities(v *InlineCompletionClientCapabilities) ResolvedInlineCompletionClientCapabilities { @@ -26820,38 +26820,38 @@ func resolveInlineCompletionClientCapabilities(v *InlineCompletionClientCapabili } type ResolvedTextDocumentClientCapabilities struct { - Synchronization ResolvedTextDocumentSyncClientCapabilities - Filters ResolvedTextDocumentFilterClientCapabilities - Completion ResolvedCompletionClientCapabilities - Hover ResolvedHoverClientCapabilities - SignatureHelp ResolvedSignatureHelpClientCapabilities - Declaration ResolvedDeclarationClientCapabilities - Definition ResolvedDefinitionClientCapabilities - TypeDefinition ResolvedTypeDefinitionClientCapabilities - Implementation ResolvedImplementationClientCapabilities - References ResolvedReferenceClientCapabilities - DocumentHighlight ResolvedDocumentHighlightClientCapabilities - DocumentSymbol ResolvedDocumentSymbolClientCapabilities - CodeAction ResolvedCodeActionClientCapabilities - CodeLens ResolvedCodeLensClientCapabilities - DocumentLink ResolvedDocumentLinkClientCapabilities - ColorProvider ResolvedDocumentColorClientCapabilities - Formatting ResolvedDocumentFormattingClientCapabilities - RangeFormatting ResolvedDocumentRangeFormattingClientCapabilities - OnTypeFormatting ResolvedDocumentOnTypeFormattingClientCapabilities - Rename ResolvedRenameClientCapabilities - FoldingRange ResolvedFoldingRangeClientCapabilities - SelectionRange ResolvedSelectionRangeClientCapabilities - PublishDiagnostics ResolvedPublishDiagnosticsClientCapabilities - CallHierarchy ResolvedCallHierarchyClientCapabilities - SemanticTokens ResolvedSemanticTokensClientCapabilities - LinkedEditingRange ResolvedLinkedEditingRangeClientCapabilities - Moniker ResolvedMonikerClientCapabilities - TypeHierarchy ResolvedTypeHierarchyClientCapabilities - InlineValue ResolvedInlineValueClientCapabilities - InlayHint ResolvedInlayHintClientCapabilities - Diagnostic ResolvedDiagnosticClientCapabilities - InlineCompletion ResolvedInlineCompletionClientCapabilities + Synchronization ResolvedTextDocumentSyncClientCapabilities `json:"synchronization,omitzero"` + Filters ResolvedTextDocumentFilterClientCapabilities `json:"filters,omitzero"` + Completion ResolvedCompletionClientCapabilities `json:"completion,omitzero"` + Hover ResolvedHoverClientCapabilities `json:"hover,omitzero"` + SignatureHelp ResolvedSignatureHelpClientCapabilities `json:"signatureHelp,omitzero"` + Declaration ResolvedDeclarationClientCapabilities `json:"declaration,omitzero"` + Definition ResolvedDefinitionClientCapabilities `json:"definition,omitzero"` + TypeDefinition ResolvedTypeDefinitionClientCapabilities `json:"typeDefinition,omitzero"` + Implementation ResolvedImplementationClientCapabilities `json:"implementation,omitzero"` + References ResolvedReferenceClientCapabilities `json:"references,omitzero"` + DocumentHighlight ResolvedDocumentHighlightClientCapabilities `json:"documentHighlight,omitzero"` + DocumentSymbol ResolvedDocumentSymbolClientCapabilities `json:"documentSymbol,omitzero"` + CodeAction ResolvedCodeActionClientCapabilities `json:"codeAction,omitzero"` + CodeLens ResolvedCodeLensClientCapabilities `json:"codeLens,omitzero"` + DocumentLink ResolvedDocumentLinkClientCapabilities `json:"documentLink,omitzero"` + ColorProvider ResolvedDocumentColorClientCapabilities `json:"colorProvider,omitzero"` + Formatting ResolvedDocumentFormattingClientCapabilities `json:"formatting,omitzero"` + RangeFormatting ResolvedDocumentRangeFormattingClientCapabilities `json:"rangeFormatting,omitzero"` + OnTypeFormatting ResolvedDocumentOnTypeFormattingClientCapabilities `json:"onTypeFormatting,omitzero"` + Rename ResolvedRenameClientCapabilities `json:"rename,omitzero"` + FoldingRange ResolvedFoldingRangeClientCapabilities `json:"foldingRange,omitzero"` + SelectionRange ResolvedSelectionRangeClientCapabilities `json:"selectionRange,omitzero"` + PublishDiagnostics ResolvedPublishDiagnosticsClientCapabilities `json:"publishDiagnostics,omitzero"` + CallHierarchy ResolvedCallHierarchyClientCapabilities `json:"callHierarchy,omitzero"` + SemanticTokens ResolvedSemanticTokensClientCapabilities `json:"semanticTokens,omitzero"` + LinkedEditingRange ResolvedLinkedEditingRangeClientCapabilities `json:"linkedEditingRange,omitzero"` + Moniker ResolvedMonikerClientCapabilities `json:"moniker,omitzero"` + TypeHierarchy ResolvedTypeHierarchyClientCapabilities `json:"typeHierarchy,omitzero"` + InlineValue ResolvedInlineValueClientCapabilities `json:"inlineValue,omitzero"` + InlayHint ResolvedInlayHintClientCapabilities `json:"inlayHint,omitzero"` + Diagnostic ResolvedDiagnosticClientCapabilities `json:"diagnostic,omitzero"` + InlineCompletion ResolvedInlineCompletionClientCapabilities `json:"inlineCompletion,omitzero"` } func resolveTextDocumentClientCapabilities(v *TextDocumentClientCapabilities) ResolvedTextDocumentClientCapabilities { @@ -26895,8 +26895,8 @@ func resolveTextDocumentClientCapabilities(v *TextDocumentClientCapabilities) Re } type ResolvedNotebookDocumentSyncClientCapabilities struct { - DynamicRegistration bool - ExecutionSummarySupport bool + DynamicRegistration bool `json:"dynamicRegistration,omitzero"` + ExecutionSummarySupport bool `json:"executionSummarySupport,omitzero"` } func resolveNotebookDocumentSyncClientCapabilities(v *NotebookDocumentSyncClientCapabilities) ResolvedNotebookDocumentSyncClientCapabilities { @@ -26910,7 +26910,7 @@ func resolveNotebookDocumentSyncClientCapabilities(v *NotebookDocumentSyncClient } type ResolvedNotebookDocumentClientCapabilities struct { - Synchronization ResolvedNotebookDocumentSyncClientCapabilities + Synchronization ResolvedNotebookDocumentSyncClientCapabilities `json:"synchronization,omitzero"` } func resolveNotebookDocumentClientCapabilities(v *NotebookDocumentClientCapabilities) ResolvedNotebookDocumentClientCapabilities { @@ -26923,7 +26923,7 @@ func resolveNotebookDocumentClientCapabilities(v *NotebookDocumentClientCapabili } type ResolvedClientShowMessageActionItemOptions struct { - AdditionalPropertiesSupport bool + AdditionalPropertiesSupport bool `json:"additionalPropertiesSupport,omitzero"` } func resolveClientShowMessageActionItemOptions(v *ClientShowMessageActionItemOptions) ResolvedClientShowMessageActionItemOptions { @@ -26936,7 +26936,7 @@ func resolveClientShowMessageActionItemOptions(v *ClientShowMessageActionItemOpt } type ResolvedShowMessageRequestClientCapabilities struct { - MessageActionItem ResolvedClientShowMessageActionItemOptions + MessageActionItem ResolvedClientShowMessageActionItemOptions `json:"messageActionItem,omitzero"` } func resolveShowMessageRequestClientCapabilities(v *ShowMessageRequestClientCapabilities) ResolvedShowMessageRequestClientCapabilities { @@ -26949,7 +26949,7 @@ func resolveShowMessageRequestClientCapabilities(v *ShowMessageRequestClientCapa } type ResolvedShowDocumentClientCapabilities struct { - Support bool + Support bool `json:"support,omitzero"` } func resolveShowDocumentClientCapabilities(v *ShowDocumentClientCapabilities) ResolvedShowDocumentClientCapabilities { @@ -26962,9 +26962,9 @@ func resolveShowDocumentClientCapabilities(v *ShowDocumentClientCapabilities) Re } type ResolvedWindowClientCapabilities struct { - WorkDoneProgress bool - ShowMessage ResolvedShowMessageRequestClientCapabilities - ShowDocument ResolvedShowDocumentClientCapabilities + WorkDoneProgress bool `json:"workDoneProgress,omitzero"` + ShowMessage ResolvedShowMessageRequestClientCapabilities `json:"showMessage,omitzero"` + ShowDocument ResolvedShowDocumentClientCapabilities `json:"showDocument,omitzero"` } func resolveWindowClientCapabilities(v *WindowClientCapabilities) ResolvedWindowClientCapabilities { @@ -26979,8 +26979,8 @@ func resolveWindowClientCapabilities(v *WindowClientCapabilities) ResolvedWindow } type ResolvedStaleRequestSupportOptions struct { - Cancel bool - RetryOnContentModified []string + Cancel bool `json:"cancel,omitzero"` + RetryOnContentModified []string `json:"retryOnContentModified,omitzero"` } func resolveStaleRequestSupportOptions(v *StaleRequestSupportOptions) ResolvedStaleRequestSupportOptions { @@ -26994,8 +26994,8 @@ func resolveStaleRequestSupportOptions(v *StaleRequestSupportOptions) ResolvedSt } type ResolvedRegularExpressionsClientCapabilities struct { - Engine string - Version string + Engine string `json:"engine,omitzero"` + Version string `json:"version,omitzero"` } func resolveRegularExpressionsClientCapabilities(v *RegularExpressionsClientCapabilities) ResolvedRegularExpressionsClientCapabilities { @@ -27009,9 +27009,9 @@ func resolveRegularExpressionsClientCapabilities(v *RegularExpressionsClientCapa } type ResolvedMarkdownClientCapabilities struct { - Parser string - Version string - AllowedTags []string + Parser string `json:"parser,omitzero"` + Version string `json:"version,omitzero"` + AllowedTags []string `json:"allowedTags,omitzero"` } func resolveMarkdownClientCapabilities(v *MarkdownClientCapabilities) ResolvedMarkdownClientCapabilities { @@ -27026,10 +27026,10 @@ func resolveMarkdownClientCapabilities(v *MarkdownClientCapabilities) ResolvedMa } type ResolvedGeneralClientCapabilities struct { - StaleRequestSupport ResolvedStaleRequestSupportOptions - RegularExpressions ResolvedRegularExpressionsClientCapabilities - Markdown ResolvedMarkdownClientCapabilities - PositionEncodings []PositionEncodingKind + StaleRequestSupport ResolvedStaleRequestSupportOptions `json:"staleRequestSupport,omitzero"` + RegularExpressions ResolvedRegularExpressionsClientCapabilities `json:"regularExpressions,omitzero"` + Markdown ResolvedMarkdownClientCapabilities `json:"markdown,omitzero"` + PositionEncodings []PositionEncodingKind `json:"positionEncodings,omitzero"` } func resolveGeneralClientCapabilities(v *GeneralClientCapabilities) ResolvedGeneralClientCapabilities { @@ -27048,12 +27048,12 @@ func resolveGeneralClientCapabilities(v *GeneralClientCapabilities) ResolvedGene // fields are values (not pointers), making it easier to access deeply nested capabilities. // Use ResolveClientCapabilities to convert from ClientCapabilities. type ResolvedClientCapabilities struct { - Workspace ResolvedWorkspaceClientCapabilities - TextDocument ResolvedTextDocumentClientCapabilities - NotebookDocument ResolvedNotebookDocumentClientCapabilities - Window ResolvedWindowClientCapabilities - General ResolvedGeneralClientCapabilities - Experimental any + Workspace ResolvedWorkspaceClientCapabilities `json:"workspace,omitzero"` + TextDocument ResolvedTextDocumentClientCapabilities `json:"textDocument,omitzero"` + NotebookDocument ResolvedNotebookDocumentClientCapabilities `json:"notebookDocument,omitzero"` + Window ResolvedWindowClientCapabilities `json:"window,omitzero"` + General ResolvedGeneralClientCapabilities `json:"general,omitzero"` + Experimental any `json:"experimental,omitzero"` } func ResolveClientCapabilities(v *ClientCapabilities) ResolvedClientCapabilities { From 3bba939d0e53b17a6926b9259d0e8dcea0ae40ad Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 14 Nov 2025 13:58:13 -0800 Subject: [PATCH 8/8] Print resolved caps on startup --- internal/lsp/server.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/internal/lsp/server.go b/internal/lsp/server.go index 923888e7da..0a65133a63 100644 --- a/internal/lsp/server.go +++ b/internal/lsp/server.go @@ -14,6 +14,7 @@ import ( "github.com/go-json-experiment/json" "github.com/microsoft/typescript-go/internal/collections" "github.com/microsoft/typescript-go/internal/core" + "github.com/microsoft/typescript-go/internal/jsonutil" "github.com/microsoft/typescript-go/internal/ls" "github.com/microsoft/typescript-go/internal/ls/lsconv" "github.com/microsoft/typescript-go/internal/ls/lsutil" @@ -587,6 +588,13 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ s.initializeParams = params s.clientCapabilities = resolveClientCapabilities(params.Capabilities) + if _, err := fmt.Fprint(s.stderr, "Resolved client capabilities: "); err != nil { + return nil, err + } + if err := jsonutil.MarshalIndentWrite(s.stderr, &s.clientCapabilities, "", "\t"); err != nil { + return nil, err + } + s.positionEncoding = lsproto.PositionEncodingKindUTF16 if slices.Contains(s.clientCapabilities.General.PositionEncodings, lsproto.PositionEncodingKindUTF8) { s.positionEncoding = lsproto.PositionEncodingKindUTF8