Struct Backend 

pub struct Backend {
    pub client: Client,
    pub fixture_db: Arc<FixtureDatabase>,
    pub workspace_root: Arc<RwLock<Option<PathBuf>>>,
    pub original_workspace_root: Arc<RwLock<Option<PathBuf>>>,
    pub scan_task: Arc<Mutex<Option<JoinHandle<()>>>>,
    pub uri_cache: Arc<DashMap<PathBuf, Uri>>,
    pub config: Arc<RwLock<Config>>,
}

The LSP Backend struct containing server state.

Fields

client: Client

fixture_db: Arc<FixtureDatabase>

workspace_root: Arc<RwLock<Option<PathBuf>>>

The canonical workspace root path (resolved symlinks)

original_workspace_root: Arc<RwLock<Option<PathBuf>>>

The original workspace root path as provided by the client (may contain symlinks)

scan_task: Arc<Mutex<Option<JoinHandle<()>>>>

Handle to the background workspace scan task, used for cancellation on shutdown

uri_cache: Arc<DashMap<PathBuf, Uri>>

Cache mapping canonical paths to original URIs from the client This ensures we respond with URIs the client recognizes

config: Arc<RwLock<Config>>

Configuration loaded from pyproject.toml

Implementations

impl Backend

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

Handle prepareCallHierarchy request.

Returns a CallHierarchyItem for the fixture at the cursor position.

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

Handle callHierarchy/incomingCalls request.

Returns all fixtures and tests that use the given fixture.

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

Handle callHierarchy/outgoingCalls request.

Returns all fixtures that the given fixture depends on.

impl Backend

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

Handle textDocument/codeAction request.

impl Backend

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

Handle code lens request - returns lenses for all fixtures in the file

impl Backend

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

Handle completion request

impl Backend

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

Handle goto_definition request

impl Backend

pub async fn publish_diagnostics_for_file(&self, uri: &Uri, file_path: &Path)

Publish diagnostics for undeclared fixtures and circular dependencies in a file

impl Backend

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

Handle textDocument/documentSymbol request.

Returns all fixture definitions in the document as symbols. This enables outline view and breadcrumb navigation in editors.

impl Backend

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

Handle hover request

impl Backend

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

Handle goto_implementation request.

For fixtures, “implementation” is the yield statement (if present). This allows jumping to where the fixture value is actually produced in generator fixtures.

impl Backend

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

Handle inlay hints request.

Returns type hints for fixture parameters when the fixture has an explicit return type annotation. This helps developers understand what type each fixture provides without having to navigate to its definition.

Skips parameters that already have a type annotation to avoid redundancy.

impl Backend

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

Handle references request

impl Backend

pub async fn handle_workspace_symbol( &self, params: WorkspaceSymbolParams, ) -> Result<Option<Vec<SymbolInformation>>>

Handle workspace/symbol request.

Returns all fixture definitions matching the query string. This enables “Go to Symbol in Workspace” (Cmd+T / Ctrl+T) in editors.

impl Backend

pub fn new(client: Client, fixture_db: Arc<FixtureDatabase>) -> Self

Create a new Backend instance

pub fn uri_to_path(&self, uri: &Uri) -> Option<PathBuf>

Convert URI to PathBuf with error logging Canonicalizes the path to handle symlinks (e.g., /var -> /private/var on macOS)

pub fn path_to_uri(&self, path: &Path) -> Option<Uri>

Convert PathBuf to URI with error logging First checks the URI cache for a previously seen URI, then falls back to creating one

pub fn lsp_line_to_internal(line: u32) -> usize

Convert LSP position (0-based line) to internal representation (1-based line)

pub fn internal_line_to_lsp(line: usize) -> u32

Convert internal line (1-based) to LSP position (0-based)

pub fn create_range( start_line: u32, start_char: u32, end_line: u32, end_char: u32, ) -> Range

Create a Range from start and end positions

pub fn create_point_range(line: u32, character: u32) -> Range

Create a point Range (start == end) for a single position

pub fn format_fixture_documentation( fixture: &FixtureDefinition, workspace_root: Option<&PathBuf>, ) -> String

Format fixture documentation for display (used in both hover and completions)

Trait Implementations

impl LanguageServer for Backend

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, _: 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_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_change_watched_files(&self, params: DidChangeWatchedFilesParams)

The workspace/didChangeWatchedFiles notification is sent from the client to the server when the client detects changes to files watched by the language client.

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 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 goto_implementation( &self, params: GotoImplementationParams, ) -> Result<Option<GotoImplementationResponse>>

The textDocument/implementation request is sent from the client to the server to resolve the implementation location of a symbol at a given text document 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 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 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 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 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 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 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 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.

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

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

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 goto_declaration( &self, params: GotoDefinitionParams, ) -> impl Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + Send

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

fn goto_type_definition( &self, params: GotoDefinitionParams, ) -> impl Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + Send

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

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_highlight( &self, params: DocumentHighlightParams, ) -> impl Future<Output = Result<Option<Vec<DocumentHighlight>>, Error>> + Send

The textDocument/documentHighlight request is sent from the client to the server to resolve appropriate highlights for a given text document position.

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

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

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 code_lens_resolve( &self, params: CodeLens, ) -> impl Future<Output = Result<CodeLens, Error>> + Send

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

fn folding_range( &self, params: FoldingRangeParams, ) -> impl Future<Output = Result<Option<Vec<FoldingRange>>, Error>> + Send

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

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 semantic_tokens_full( &self, params: SemanticTokensParams, ) -> impl Future<Output = Result<Option<SemanticTokensResult>, Error>> + Send

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

fn semantic_tokens_full_delta( &self, params: SemanticTokensDeltaParams, ) -> impl Future<Output = Result<Option<SemanticTokensFullDeltaResult>, Error>> + Send

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.

fn semantic_tokens_range( &self, params: SemanticTokensRangeParams, ) -> impl Future<Output = Result<Option<SemanticTokensRangeResult>, Error>> + Send

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.

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 inlay_hint_resolve( &self, params: InlayHint, ) -> impl Future<Output = Result<InlayHint, Error>> + Send

The inlayHint/resolve request is sent from the client to the server to resolve additional information for a given inlay hint.

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 completion_resolve( &self, params: CompletionItem, ) -> impl Future<Output = Result<CompletionItem, Error>> + Send

The completionItem/resolve request is sent from the client to the server to resolve additional information for a given completion item.

fn diagnostic( &self, params: DocumentDiagnosticParams, ) -> impl Future<Output = Result<DocumentDiagnosticReportResult, Error>> + Send

The textDocument/diagnostic request is sent from the client to the server to ask the server to compute the diagnostics for a given document.

fn workspace_diagnostic( &self, params: WorkspaceDiagnosticParams, ) -> impl Future<Output = Result<WorkspaceDiagnosticReportResult, Error>> + Send

The workspace/diagnostic request is sent from the client to the server to ask the server to compute workspace wide diagnostics which previously where pushed from the server to the client.

fn signature_help( &self, params: SignatureHelpParams, ) -> impl Future<Output = Result<Option<SignatureHelp>, Error>> + Send

The textDocument/signatureHelp request is sent from the client to the server to request signature information at a given cursor 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 formatting( &self, params: DocumentFormattingParams, ) -> impl Future<Output = Result<Option<Vec<TextEdit>>, Error>> + Send

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

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

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

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

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

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

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.

fn prepare_rename( &self, params: TextDocumentPositionParams, ) -> impl Future<Output = Result<Option<PrepareRenameResponse>, Error>> + Send

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.

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_configuration( &self, params: DidChangeConfigurationParams, ) -> impl Future<Output = ()> + Send

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

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 will_rename_files( &self, params: RenameFilesParams, ) -> impl Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send

The workspace/willRenameFiles request is sent from the client to the server before files are actually renamed as long as the rename is triggered 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.

fn execute_command( &self, params: ExecuteCommandParams, ) -> impl Future<Output = Result<Option<Value>, Error>> + Send

The workspace/executeCommand request is sent from the client to the server to trigger command execution on the server.