Struct ShapeLanguageServer 

pub struct ShapeLanguageServer { /* private fields */ }

The main Shape Language Server

Implementations

impl ShapeLanguageServer

pub fn new(client: Client) -> Self

Create a new language server instance

Trait Implementations

impl LanguageServer for ShapeLanguageServer

async fn completion_resolve( &self, item: CompletionItem, ) -> Result<CompletionItem>

completionItem/resolve — lazy detail expansion (LSP feature 1.10).

Today every completion item ships its full payload (label, detail, documentation, snippet) inline from the completion handler. The resolver therefore behaves as an identity pass-through so the round- trip is cheap and clients that route through resolve still get the full item back. W2.2 lays the protocol foundation; downstream waves can swap in genuinely-deferred metadata producers without changing the registered capability.

async fn goto_type_definition( &self, params: GotoTypeDefinitionParams, ) -> Result<Option<GotoTypeDefinitionResponse>>

W2.5 / feature 1.33 (textDocument/typeDefinition): jump from an expression to the definition site of its type. Delegates to definition::get_type_definition, which infers the type via type_inference::infer_variable_type, strips generic wrappers, and re-uses the existing definition lookup for the resulting type name.

async fn goto_implementation( &self, params: GotoImplementationParams, ) -> Result<Option<GotoImplementationResponse>>

W2.5 / feature 1.34 (textDocument/implementation): enumerate impl Trait for Type / extend Type blocks for the trait or type at the cursor. Current-file scope only — cross-workspace impl discovery requires the W2.6 / W2.7 workspace indexing work.

async fn goto_declaration( &self, params: GotoDeclarationParams, ) -> Result<Option<GotoDeclarationResponse>>

W2.5 / feature 1.35 (textDocument/declaration): alias of textDocument/definition — Shape has no declaration/definition split. VS Code’s Go to Declaration command dispatches here.

async fn document_highlight( &self, params: DocumentHighlightParams, ) -> Result<Option<Vec<DocumentHighlight>>>

W2.5 / feature 1.60 (textDocument/documentHighlight): highlight every occurrence of the symbol at the cursor within the current file. Reuses the scope-aware ScopeTree::references_of path that powers rename.rs, so highlights respect lexical scope and variable shadowing.

async fn inlay_hint_resolve(&self, hint: InlayHint) -> Result<InlayHint>

W2.4 / 1.28: resolve a previously-returned inlay hint with additional detail. We currently fill the tooltip lazily based on the data field (set in inlay_hints.rs), so a hint emitted without an eager tooltip still surfaces context on hover.

async fn diagnostic( &self, params: DocumentDiagnosticParams, ) -> Result<DocumentDiagnosticReportResult>

W2.3 / 1.73 — pull-based diagnostics (textDocument/diagnostic).

Computes diagnostics for a single document on demand. Mirrors the existing push-based analyze_document pipeline (parse + semantic analyze + frontmatter + foreign-LSP merge) so push and pull produce identical reports for the same source. Returns a RelatedFullDocumentDiagnosticReport; we don’t currently support Unchanged reports (would require diagnostic result-id caching per document version — follow-up tier, not parity-blocking).

async fn workspace_diagnostic( &self, _params: WorkspaceDiagnosticParams, ) -> Result<WorkspaceDiagnosticReportResult>

W2.3 / 1.74 — workspace-wide pull diagnostics (workspace/diagnostic).

Returns full diagnostic reports for every open document. Closed workspace files are NOT walked from disk here — the LSP spec allows servers to scope workspace pull to documents the server already has materialized analyses for, which keeps cost bounded and avoids re-parsing the whole workspace on every refresh request. The W2.6/W2.7 workspace-enumeration infra (ModuleCache::enumerate_workspace_shape_files) is reserved for the eager-indexing follow-up.

async fn did_change_watched_files(&self, params: DidChangeWatchedFilesParams)

W2.7 / 1.69: workspace/didChangeWatchedFiles — invalidate cached state when files change on disk outside the editor (e.g. git checkout, external build script). Drops the module-cache entry for each affected .shape path (via the W2.6 invalidate hook at module_cache.rs:226) and clears the corresponding last_good_programs snapshot so the next analysis re-reads from disk. Files in any open document are left alone — the editor owns their text and the cache will refresh on the next did_change.

async fn execute_command( &self, params: ExecuteCommandParams, ) -> Result<Option<LSPAny>>

W2.7 / 1.71: workspace/executeCommand — acknowledge code-lens commands by name and return None.

Today, the code-lens commands (shape.findReferences, shape.findImplementations, shape.runTests, etc.) are designed to be invoked by the client. Registering them server-side lets editors enable the lens click-targets in the first place (without the executeCommand capability, many clients suppress the lens entirely). The server replies with None so the client falls through to its own command handler (textDocument/references for shape.findReferences, the test runner integration for shape.runTests, etc.). Unknown commands are rejected with the LSP MethodNotFound error.

async fn will_rename_files( &self, params: RenameFilesParams, ) -> Result<Option<WorkspaceEdit>>

W2.7 / 1.72: workspace/willRenameFiles — compute import-path rewrite edits before files are renamed.

For each (old_uri, new_uri) pair, derives the corresponding Shape module path via crate::module_cache::path_to_module_path (relative to project_root) and produces text edits that rewrite from OLD_PATH use ... to from NEW_PATH use ... in every importing file (open documents + workspace .shape files via the W2.6 enumerator). Files outside the workspace root, files with non-.shape extensions, and module paths containing non-identifier path segments produce no edits — the client just renames the file and the user fixes any newly-broken imports by hand.

async fn initialize(&self, params: InitializeParams) -> Result<InitializeResult>

The initialize request is the first request sent from the client to the server.

async fn initialized(&self, _params: InitializedParams)

The initialized notification is sent from the client to the server after the client received the result of the initialize request but before the client sends anything else.

async fn did_change_configuration(&self, params: DidChangeConfigurationParams)

The workspace/didChangeConfiguration notification is sent from the client to the server to signal the change of configuration settings.

async fn shutdown(&self) -> Result<()>

The shutdown request asks the server to gracefully shut down, but to not exit.

async fn did_open(&self, params: DidOpenTextDocumentParams)

The textDocument/didOpen notification is sent from the client to the server to signal that a new text document has been opened by the client.

async fn did_change(&self, params: DidChangeTextDocumentParams)

The textDocument/didChange notification is sent from the client to the server to signal changes to a text document.

async fn did_close(&self, params: DidCloseTextDocumentParams)

The textDocument/didClose notification is sent from the client to the server when the document got closed in the client.

async fn completion( &self, params: CompletionParams, ) -> Result<Option<CompletionResponse>>

The textDocument/completion request is sent from the client to the server to compute completion items at a given cursor position.

async fn hover(&self, params: HoverParams) -> Result<Option<Hover>>

The textDocument/hover request asks the server for hover information at a given text document position.

async fn signature_help( &self, params: SignatureHelpParams, ) -> Result<Option<SignatureHelp>>

The textDocument/signatureHelp request is sent from the client to the server to request signature information at a given cursor position.

async fn document_symbol( &self, params: DocumentSymbolParams, ) -> Result<Option<DocumentSymbolResponse>>

The textDocument/documentSymbol request is sent from the client to the server to retrieve all symbols found in a given text document.

async fn symbol( &self, params: WorkspaceSymbolParams, ) -> Result<Option<WorkspaceSymbolResponse>>

The workspace/symbol request is sent from the client to the server to list project-wide symbols matching the given query string.

async fn goto_definition( &self, params: GotoDefinitionParams, ) -> Result<Option<GotoDefinitionResponse>>

The textDocument/definition request asks the server for the definition location of a symbol at a given text document position.

async fn references( &self, params: ReferenceParams, ) -> Result<Option<Vec<Location>>>

The textDocument/references request is sent from the client to the server to resolve project-wide references for the symbol denoted by the given text document position.

async fn semantic_tokens_full( &self, params: SemanticTokensParams, ) -> Result<Option<SemanticTokensResult>>

The textDocument/semanticTokens/full request is sent from the client to the server to resolve the semantic tokens of a given file.

async fn semantic_tokens_range( &self, params: SemanticTokensRangeParams, ) -> Result<Option<SemanticTokensRangeResult>>

The textDocument/semanticTokens/range request is sent from the client to the server to resolve the semantic tokens for the visible range of a given file.

async fn semantic_tokens_full_delta( &self, params: SemanticTokensDeltaParams, ) -> Result<Option<SemanticTokensFullDeltaResult>>

The textDocument/semanticTokens/full/delta request is sent from the client to the server to resolve the semantic tokens of a given file, returning only the delta.

async fn inlay_hint( &self, params: InlayHintParams, ) -> Result<Option<Vec<InlayHint>>>

The textDocument/inlayHint request is sent from the client to the server to compute inlay hints for a given (text document, range) tuple that may be rendered in the editor in place with other text.

async fn code_action( &self, params: CodeActionParams, ) -> Result<Option<CodeActionResponse>>

The textDocument/codeAction request is sent from the client to the server to compute commands for a given text document and range. These commands are typically code fixes to either fix problems or to beautify/refactor code.

async fn formatting( &self, params: DocumentFormattingParams, ) -> Result<Option<Vec<TextEdit>>>

The textDocument/formatting request is sent from the client to the server to format a whole document.

async fn range_formatting( &self, params: DocumentRangeFormattingParams, ) -> Result<Option<Vec<TextEdit>>>

The textDocument/rangeFormatting request is sent from pub(crate) the client to the server to format a given range in a document.

async fn on_type_formatting( &self, params: DocumentOnTypeFormattingParams, ) -> Result<Option<Vec<TextEdit>>>

The textDocument/onTypeFormatting request is sent from the client to the server to format parts of the document during typing.

async fn prepare_rename( &self, params: TextDocumentPositionParams, ) -> Result<Option<PrepareRenameResponse>>

The textDocument/prepareRename request is sent from the client to the server to setup and test the validity of a rename operation at a given location.

async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>>

The textDocument/rename request is sent from the client to the server to ask the server to compute a workspace change so that the client can perform a workspace-wide rename of a symbol.

async fn code_lens( &self, params: CodeLensParams, ) -> Result<Option<Vec<CodeLens>>>

The textDocument/codeLens request is sent from the client to the server to compute code lenses for a given text document.

async fn code_lens_resolve(&self, lens: CodeLens) -> Result<CodeLens>

The codeLens/resolve request is sent from the client to the server to resolve the command for a given code lens item.

async fn folding_range( &self, params: FoldingRangeParams, ) -> Result<Option<Vec<FoldingRange>>>

The textDocument/foldingRange request is sent from the client to the server to return all folding ranges found in a given text document.

async fn document_link( &self, params: DocumentLinkParams, ) -> Result<Option<Vec<DocumentLink>>>

The textDocument/documentLink request is sent from the client to the server to request the location of links in a document.

async fn prepare_call_hierarchy( &self, params: CallHierarchyPrepareParams, ) -> Result<Option<Vec<CallHierarchyItem>>>

The textDocument/prepareCallHierarchy request is sent from the client to the server to return a call hierarchy for the language element of given text document positions.

async fn incoming_calls( &self, params: CallHierarchyIncomingCallsParams, ) -> Result<Option<Vec<CallHierarchyIncomingCall>>>

The callHierarchy/incomingCalls request is sent from the client to the server to resolve incoming calls for a given call hierarchy item.

async fn outgoing_calls( &self, params: CallHierarchyOutgoingCallsParams, ) -> Result<Option<Vec<CallHierarchyOutgoingCall>>>

The callHierarchy/outgoingCalls request is sent from the client to the server to resolve outgoing calls for a given call hierarchy item.

fn will_save( &self, params: WillSaveTextDocumentParams, ) -> impl Future<Output = ()> + Send

The textDocument/willSave notification is sent from the client to the server before the document is actually saved.

fn will_save_wait_until( &self, params: WillSaveTextDocumentParams, ) -> impl Future<Output = Result<Option<Vec<TextEdit>>, Error>> + Send

The textDocument/willSaveWaitUntil request is sent from the client to the server before the document is actually saved.

fn did_save( &self, params: DidSaveTextDocumentParams, ) -> impl Future<Output = ()> + Send

The textDocument/didSave notification is sent from the client to the server when the document was saved in the client.

fn notebook_did_open( &self, params: DidOpenNotebookDocumentParams, ) -> impl Future<Output = ()> + Send

The notebookDocument/didOpen notification is sent from the client to the server when a new notebook document is opened. It is only sent for notebooks selected by the notebookDocumentSync server capability.

fn notebook_did_change( &self, params: DidChangeNotebookDocumentParams, ) -> impl Future<Output = ()> + Send

The notebookDocument/didChange notification is sent from the client to the server when a notebook document changes. It is only sent for notebooks selected by the notebookDocumentSync server capability.

fn notebook_did_save( &self, params: DidSaveNotebookDocumentParams, ) -> impl Future<Output = ()> + Send

The notebookDocument/didSave notification is sent from the client to the server when a notebook document is saved. It is only sent for notebooks selected by the notebookDocumentSync server capability.

fn notebook_did_close( &self, params: DidCloseNotebookDocumentParams, ) -> impl Future<Output = ()> + Send

The notebookDocument/didClose notification is sent from the client to the server when a notebook document is closed. It is only sent for notebooks selected by the notebookDocumentSync server capability.

fn prepare_type_hierarchy( &self, params: TypeHierarchyPrepareParams, ) -> impl Future<Output = Result<Option<Vec<TypeHierarchyItem>>, Error>> + Send

The textDocument/prepareTypeHierarchy request is sent from the client to the server to return a type hierarchy for the language element of given text document positions.

fn supertypes( &self, params: TypeHierarchySupertypesParams, ) -> impl Future<Output = Result<Option<Vec<TypeHierarchyItem>>, Error>> + Send

The [typeHierarchy/supertypes] request is sent from the client to the server to resolve the supertypes for a given type hierarchy item.

fn subtypes( &self, params: TypeHierarchySubtypesParams, ) -> impl Future<Output = Result<Option<Vec<TypeHierarchyItem>>, Error>> + Send

The [typeHierarchy/subtypes] request is sent from the client to the server to resolve the subtypes for a given type hierarchy item.

fn document_link_resolve( &self, params: DocumentLink, ) -> impl Future<Output = Result<DocumentLink, Error>> + Send

The documentLink/resolve request is sent from the client to the server to resolve the target of a given document link.

fn selection_range( &self, params: SelectionRangeParams, ) -> impl Future<Output = Result<Option<Vec<SelectionRange>>, Error>> + Send

The textDocument/selectionRange request is sent from the client to the server to return suggested selection ranges at an array of given positions. A selection range is a range around the cursor position which the user might be interested in selecting.

fn inline_value( &self, params: InlineValueParams, ) -> impl Future<Output = Result<Option<Vec<InlineValue>>, Error>> + Send

The textDocument/inlineValue request is sent from the client to the server to compute inline values for a given text document that may be rendered in the editor at the end of lines.

fn moniker( &self, params: MonikerParams, ) -> impl Future<Output = Result<Option<Vec<Moniker>>, Error>> + Send

The textDocument/moniker request is sent from the client to the server to get the symbol monikers for a given text document position.

fn code_action_resolve( &self, params: CodeAction, ) -> impl Future<Output = Result<CodeAction, Error>> + Send

The codeAction/resolve request is sent from the client to the server to resolve additional information for a given code action.

fn document_color( &self, params: DocumentColorParams, ) -> impl Future<Output = Result<Vec<ColorInformation>, Error>> + Send

The textDocument/documentColor request is sent from the client to the server to list all color references found in a given text document. Along with the range, a color value in RGB is returned.

fn color_presentation( &self, params: ColorPresentationParams, ) -> impl Future<Output = Result<Vec<ColorPresentation>, Error>> + Send

The textDocument/colorPresentation request is sent from the client to the server to obtain a list of presentations for a color value at a given location.

fn linked_editing_range( &self, params: LinkedEditingRangeParams, ) -> impl Future<Output = Result<Option<LinkedEditingRanges>, Error>> + Send

The textDocument/linkedEditingRange request is sent from the client to the server to return for a given position in a document the range of the symbol at the position and all ranges that have the same content.

fn symbol_resolve( &self, params: WorkspaceSymbol, ) -> impl Future<Output = Result<WorkspaceSymbol, Error>> + Send

The workspaceSymbol/resolve request is sent from the client to the server to resolve additional information for a given workspace symbol.

fn did_change_workspace_folders( &self, params: DidChangeWorkspaceFoldersParams, ) -> impl Future<Output = ()> + Send

The workspace/didChangeWorkspaceFolders notification is sent from the client to the server to inform about workspace folder configuration changes.

fn will_create_files( &self, params: CreateFilesParams, ) -> impl Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send

The workspace/willCreateFiles request is sent from the client to the server before files are actually created as long as the creation is triggered from within the client.

fn did_create_files( &self, params: CreateFilesParams, ) -> impl Future<Output = ()> + Send

The workspace/didCreateFiles request is sent from the client to the server when files were created from within the client.

fn did_rename_files( &self, params: RenameFilesParams, ) -> impl Future<Output = ()> + Send

The workspace/didRenameFiles notification is sent from the client to the server when files were renamed from within the client.

fn will_delete_files( &self, params: DeleteFilesParams, ) -> impl Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send

The workspace/willDeleteFiles request is sent from the client to the server before files are actually deleted as long as the deletion is triggered from within the client either by a user action or by applying a workspace edit.

fn did_delete_files( &self, params: DeleteFilesParams, ) -> impl Future<Output = ()> + Send

The workspace/didDeleteFiles notification is sent from the client to the server when files were deleted from within the client.