cpp_ls 0.1.1

A C, C++ and CUDA language server.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! # Unified analysis query runner
//!
//! All pull requests go through here:
//! - completed normally → `Ready`
//! - genuinely no data → `Missing`
//! - external cancellation / replaced by latest-wins → `Cancelled(Client)`

use super::{AnalysisState, RequestManager};
use cpp_code_analysis::{DiskFiles, Session};
use tokio_util::sync::CancellationToken;

/// Cancellation source.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CancelSource {
    /// Client `$/cancelRequest`, or a newer same-key request replacing the old one.
    Client,
}

/// Unified request result.
#[derive(Debug)]
pub enum RequestOutcome<T> {
    Ready(T),
    Cancelled(CancelSource),
    Missing,
}

impl<T> RequestOutcome<T> {
    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> RequestOutcome<U> {
        match self {
            RequestOutcome::Ready(value) => RequestOutcome::Ready(f(value)),
            RequestOutcome::Cancelled(source) => RequestOutcome::Cancelled(source),
            RequestOutcome::Missing => RequestOutcome::Missing,
        }
    }
}

/// Unified executor for pull requests with PullCache.
pub async fn analysis_query<T, F>(
    analysis: &AnalysisState,
    request_manager: &RequestManager,
    key: &str,
    cancel_token: Option<CancellationToken>,
    compute: F,
) -> RequestOutcome<T>
where
    T: Send + Sync + 'static,
    F: FnOnce(&Session<DiskFiles>) -> Option<T> + Send + 'static,
{
    if let Some(token) = &cancel_token {
        request_manager.begin(key, token.clone()).await;
    }
    let key_owner = request_manager.lock_for(key).await;
    let _guard = key_owner.lock().await;

    if let Some(token) = &cancel_token
        && token.is_cancelled()
    {
        return RequestOutcome::Cancelled(CancelSource::Client);
    }

    let started = std::time::Instant::now();
    let outcome = analysis.query_blocking(compute).await;
    let took = started.elapsed().as_millis();
    if took > 100 {
        log::debug!("a query waited {took} ms for the analysis");
    }
    match outcome {
        RequestOutcome::Ready(value) => RequestOutcome::Ready(value),
        RequestOutcome::Missing => {
            if let Some(token) = &cancel_token
                && token.is_cancelled()
            {
                RequestOutcome::Cancelled(CancelSource::Client)
            } else {
                RequestOutcome::Missing
            }
        }
        RequestOutcome::Cancelled(CancelSource::Client) => {
            RequestOutcome::Cancelled(CancelSource::Client)
        }
    }
}

/// Unified executor for plain snapshot queries without PullCache.
pub async fn snapshot_query<T, F>(
    analysis: &AnalysisState,
    cancel_token: CancellationToken,
    compute: F,
) -> RequestOutcome<T>
where
    T: Send + Sync + 'static,
    F: FnOnce(&Session<DiskFiles>) -> Option<T> + Send + 'static,
{
    if cancel_token.is_cancelled() {
        return RequestOutcome::Cancelled(CancelSource::Client);
    }

    let started = std::time::Instant::now();
    let outcome = analysis.query_blocking(compute).await;
    let took = started.elapsed().as_millis();
    if took > 100 {
        log::debug!("a query waited {took} ms for the analysis");
    }
    match outcome {
        RequestOutcome::Ready(value) => RequestOutcome::Ready(value),
        RequestOutcome::Missing => {
            if cancel_token.is_cancelled() {
                RequestOutcome::Cancelled(CancelSource::Client)
            } else {
                RequestOutcome::Missing
            }
        }
        RequestOutcome::Cancelled(CancelSource::Client) => {
            RequestOutcome::Cancelled(CancelSource::Client)
        }
    }
}