Method references

src/server.rs:713–761

(&self, params: ReferenceParams)

    }

    async fn references(&self, params: ReferenceParams) -> Result<Option<Vec<Location>>> {
        let uri = params.text_document_position.text_document.uri.to_string();
        let position = params.text_document_position.position;
        let include_declaration = params.context.include_declaration;
        let token = match params.work_done_progress_params.work_done_token {
            Some(t) => Some(t),
            None => self.progress_create("find_references").await,
        };

        if let Some(ref tok) = token {
            self.progress_begin(tok, "Find References", Some("Scanning…".to_string()))
                .await;
        }

        // Run on a blocking thread so the async runtime stays free to
        // flush progress notifications to the client.
        //
        // We wrap spawn_blocking inside tokio::spawn so the blocking
        // task is always awaited to completion even if tower-lsp
        // cancels this handler future via $/cancelRequest.  Without
        // this wrapper, dropping the handler future detaches the
        // spawn_blocking JoinHandle, and tower-lsp 0.20 may corrupt
        // its internal state when the orphaned task completes.
        let backend = self.clone_for_blocking();
        let uri_clone = uri.clone();
        let result = tokio::spawn(async move {
            tokio::task::spawn_blocking(move || {
                backend.handle_with_position("references", &uri_clone, position, |content, pos| {
                    backend
                        .find_references(&uri_clone, content, pos, include_declaration)
                        .map(|locs| {
                            locs.into_iter()
                                .map(|l| backend.translate_location(l))
                                .collect()
                        })
                })
            })
            .await
            .unwrap_or(Ok(None))
        })
        .await
        .unwrap_or(Ok(None));

        if let Some(ref tok) = token {
            self.progress_end(tok, Some("Done".to_string())).await;
        }

        result
    }

    async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
        let uri = params.text_document.uri.to_string();