php-lsp 0.8.0

A PHP Language Server Protocol implementation
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

//! `symbol_map` salsa query — derives a [`SymbolMap`] from a parsed document.
//!
//! Depends on `parsed_doc`, so editing a file reparses once and then the symbol
//! map rebuilds. Between edits all lookups are served from the cache in O(1).

use std::sync::Arc;

use salsa::Database;

use crate::db::input::SourceFile;
use crate::db::parse::parsed_doc;
use crate::symbol_map::SymbolMap;

/// Arc wrapper for [`SymbolMap`]. Pointer equality drives salsa invalidation:
/// every `build` call produces a new `Arc`, so a changed parse always propagates.
#[derive(Clone)]
pub struct SymbolMapArc(pub Arc<SymbolMap>);

impl SymbolMapArc {
    pub fn get(&self) -> &SymbolMap {
        &self.0
    }
}

crate::impl_arc_update!(SymbolMapArc);

/// Build the symbol map for a file. `no_eq` because `SymbolMapArc` has no
/// structural equality — invalidation flows from `parsed_doc`.
#[salsa::tracked(no_eq)]
pub fn symbol_map(db: &dyn Database, file: SourceFile) -> SymbolMapArc {
    let doc = parsed_doc(db, file);
    SymbolMapArc(Arc::new(SymbolMap::build(doc.get())))
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;
    use std::sync::atomic::{AtomicUsize, Ordering};

    use salsa::Setter;

    use super::*;
    use crate::db::analysis::AnalysisHost;
    use crate::db::input::{FileId, SourceFile};

    static MEMO_CALLS: AtomicUsize = AtomicUsize::new(0);
    static INVAL_CALLS: AtomicUsize = AtomicUsize::new(0);

    #[salsa::tracked]
    fn counted_memo(db: &dyn Database, file: SourceFile) -> usize {
        MEMO_CALLS.fetch_add(1, Ordering::SeqCst);
        symbol_map(db, file)
            .get()
            .lookup("greet", |_| true)
            .is_some() as usize
    }

    #[salsa::tracked]
    fn counted_inval(db: &dyn Database, file: SourceFile) -> usize {
        INVAL_CALLS.fetch_add(1, Ordering::SeqCst);
        symbol_map(db, file)
            .get()
            .lookup("greet", |_| true)
            .is_some() as usize
    }

    #[test]
    fn symbol_map_builds_and_memoizes() {
        MEMO_CALLS.store(0, Ordering::SeqCst);
        let mut host = AnalysisHost::new();
        let file = SourceFile::new(
            host.db(),
            FileId(100),
            Arc::<str>::from("file:///memo.php"),
            Arc::<str>::from("<?php\nfunction greet(): void {}"),
            None,
        );

        let _ = counted_memo(host.db(), file);
        let _ = counted_memo(host.db(), file);
        assert_eq!(
            MEMO_CALLS.load(Ordering::SeqCst),
            1,
            "salsa should memoize the second call with unchanged input"
        );
    }

    #[test]
    fn symbol_map_invalidates_on_edit() {
        INVAL_CALLS.store(0, Ordering::SeqCst);
        let mut host = AnalysisHost::new();
        let file = SourceFile::new(
            host.db(),
            FileId(101),
            Arc::<str>::from("file:///inval.php"),
            Arc::<str>::from("<?php\nfunction greet(): void {}"),
            None,
        );

        let _ = counted_inval(host.db(), file);
        assert_eq!(INVAL_CALLS.load(Ordering::SeqCst), 1);

        file.set_text(host.db_mut())
            .to(Arc::<str>::from("<?php\nfunction farewell(): void {}"));
        let _ = counted_inval(host.db(), file);
        assert_eq!(
            INVAL_CALLS.load(Ordering::SeqCst),
            2,
            "symbol_map should re-run after source text change"
        );
    }
}