Method diagnostic

src/server.rs:1196–1256

(
        &self,
        params: DocumentDiagnosticParams,
    )

    }

    async fn diagnostic(
        &self,
        params: DocumentDiagnosticParams,
    ) -> Result<DocumentDiagnosticReportResult> {
        let uri_str = params.text_document.uri.to_string();

        // Check resultId — if the client sends back the same resultId we
        // last returned AND the full cache is still present (not
        // invalidated by schedule_diagnostics), the diagnostics have not
        // changed and we can return Unchanged immediately.
        let cache_present = self.diag_last_full.lock().contains_key(&uri_str);
        if cache_present && let Some(prev_id) = &params.previous_result_id {
            let ids = self.diag_result_ids.lock();
            if let Some(&current_id) = ids.get(&uri_str)
                && prev_id == &current_id.to_string()
            {
                return Ok(DocumentDiagnosticReportResult::Report(
                    DocumentDiagnosticReport::Unchanged(RelatedUnchangedDocumentDiagnosticReport {
                        related_documents: None,
                        unchanged_document_diagnostic_report: UnchangedDocumentDiagnosticReport {
                            result_id: current_id.to_string(),
                        },
                    }),
                ));
            }
        }

        // In pull mode the pull request *triggers* native diagnostic
        // computation (no debounce — the IDE decided "now is the time").
        // If the full cache is missing for this URI, run the native
        // pipeline immediately and block until it finishes.  External
        // tool results (PHPStan, PHPCS, Mago) are delivered
        // incrementally via publishDiagnostics as each finishes; we do
        // not block on them here to keep the pull response fast.
        let needs_compute = {
            let cache = self.diag_last_full.lock();
            !cache.contains_key(&uri_str)
        };

        if needs_compute {
            self.trigger_diagnostics_for_pull(&uri_str).await;
        }

        let (diagnostics, result_id) = {
            let cache = self.diag_last_full.lock();
            let ids = self.diag_result_ids.lock();
            let diags = cache.get(&uri_str).cloned().unwrap_or_default();
            let rid = ids.get(&uri_str).copied().unwrap_or(0).to_string();
            (diags, rid)
        };

        Ok(DocumentDiagnosticReportResult::Report(
            DocumentDiagnosticReport::Full(RelatedFullDocumentDiagnosticReport {
                related_documents: None,
                full_document_diagnostic_report: FullDocumentDiagnosticReport {
                    result_id: Some(result_id),
                    items: diagnostics,
                },