Method collect_slow_diagnostics

src/diagnostics/mod.rs:217–280

Collect Phase 2 (slow) diagnostics: unknown class/member/function, argument count, implementation errors, deprecated usage. These require type resolution and are expensive.

(
        &self,
        uri_str: &str,
        content: &str,
        out: &mut Vec<Diagnostic>,
    )

    /// argument count, implementation errors, deprecated usage.  These
    /// require type resolution and are expensive.
    pub fn collect_slow_diagnostics(
        &self,
        uri_str: &str,
        content: &str,
        out: &mut Vec<Diagnostic>,
    ) {
        // Activate the chain resolution cache so that all slow
        // diagnostic collectors share cached intermediate chain
        // prefix results (e.g. `$model->where(...)` resolved once
        // and reused by `$model->where(...)->whereNotNull(...)`).
        // This eliminates O(depth²) re-resolution of shared chain
        // prefixes across unknown_member, argument_count, type_error,
        // and deprecated collectors.
        let _chain_guard = crate::completion::resolver::with_chain_resolution_cache();

        // Activate the callable target cache so that the same method
        // on the same class is resolved at most once across all
        // diagnostic collectors.  For example, `Builder::where` is
        // looked up once and reused for every `$q->where(...)`,
        // `$query->where(...)`, and `Product::query()->where(...)`
        // call site in the file.
        let _callable_guard = crate::completion::call_resolution::with_callable_target_cache();
        let _body_infer_guard = self.activate_body_return_inferrer();

        // ── Phase 2: forward-walked diagnostic scope cache ──────
        // Walk every function/method body in the file once with the
        // forward walker, recording scope snapshots at each statement
        // boundary.  All subsequent `resolve_variable_types` calls
        // from diagnostic collectors hit the cache (O(log N) lookup)
        // instead of doing a full backward scan per member-access
        // span.  This eliminates the O(N × depth × file_size) cost
        // that caused multi-minute analysis times on large files.
        let _scope_guard = crate::completion::variable::forward_walk::with_diagnostic_scope_cache();
        {
            let file_ctx = self.file_context(uri_str);
            let class_loader = self.class_loader(&file_ctx);
            let function_loader_cl = self.function_loader(&file_ctx);
            let constant_loader_cl = self.constant_loader();
            let loaders = crate::completion::resolver::Loaders {
                function_loader: Some(&function_loader_cl),
                constant_loader: Some(&constant_loader_cl),
            };
            crate::completion::variable::forward_walk::build_diagnostic_scopes(
                content,
                &file_ctx.classes,
                &class_loader,
                loaders,
                Some(&self.resolved_class_cache),
            );
        }

        self.collect_unknown_class_diagnostics(uri_str, content, out);
        self.collect_unknown_member_diagnostics(uri_str, content, out);
        self.collect_unknown_function_diagnostics(uri_str, content, out);
        // NOTE: unresolved_member_access diagnostics are now emitted
        // inside collect_unknown_member_diagnostics (in the Untyped arm)
        // to avoid a second full walk with duplicate type resolution.
        self.collect_argument_count_diagnostics(uri_str, content, out);