Method publish_diagnostics_for_file

src/diagnostics/mod.rs:656–709

Deliver diagnostics for a single file. Called from the background diagnostic worker after debouncing. Phase 1 (instant, both modes):** Run fast collectors (syntax errors, deprecated, unused imports), merge with *cached* slow and PHPStan results, and push via `publishDiagnostics`. The editor shows strikethrough and dimming within milliseconds. Phase 2 (background, mode-dependent): - **Pull mod

(&self, uri_str: &str, content: &str)

    ///   push the full set (fast + fresh slow + cached PHPStan),
    ///   replacing the Phase 1 snapshot.
    pub(crate) async fn publish_diagnostics_for_file(&self, uri_str: &str, content: &str) {
        if self.should_skip_diagnostics(uri_str) {
            return;
        }

        // ── Phase 1: collect and cache fast diagnostics ─────────────
        let mut fast_diagnostics = Vec::new();
        {
            let vc_handle = self.blade_virtual_content.read();
            let effective_content = vc_handle
                .get(uri_str)
                .map(|s| s.as_str())
                .unwrap_or(content);

            self.collect_fast_diagnostics(uri_str, effective_content, &mut fast_diagnostics);
        }

        {
            let mut cache = self.diag_last_fast.lock();
            cache.insert(uri_str.to_string(), fast_diagnostics.clone());
        }

        // Push assembled diagnostics immediately so the editor sees
        // fast results (strikethrough, dimming) merged with whatever
        // slow / external results are already cached.
        self.assemble_and_push(uri_str).await;

        // ── Phase 2: compute and cache slow diagnostics ─────────────
        // The resolved-class cache guard must not cross an `.await`
        // point (it contains a raw pointer and is !Send).  Scope it
        // tightly around the synchronous diagnostic collection.
        let mut slow_diagnostics = Vec::new();
        {
            let _cache_guard = crate::virtual_members::with_active_resolved_class_cache(
                &self.resolved_class_cache,
            );

            let vc_handle = self.blade_virtual_content.read();
            let effective_content = vc_handle
                .get(uri_str)
                .map(|s| s.as_str())
                .unwrap_or(content);

            self.collect_slow_diagnostics(uri_str, effective_content, &mut slow_diagnostics);
        }

        {
            let mut cache = self.diag_last_slow.lock();
            cache.insert(uri_str.to_string(), slow_diagnostics);
        }

        // Push again with fresh slow results merged in.
        self.assemble_and_push(uri_str).await;
    }

    /// Assemble diagnostics from all per-source caches for a URI and
    /// deliver them to the editor.