php-lsp 0.1.48

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

#![allow(dead_code)]
/// Resolves short class/function names to fully-qualified names using
/// the `use` statements found in a PHP file.
///
/// Example: `use App\Services\Mailer;` lets callers resolve `Mailer` → `App\Services\Mailer`.
use std::collections::HashMap;

use php_ast::{NamespaceBody, Stmt, StmtKind};

use crate::ast::ParsedDoc;

/// Map of short (unqualified) name → fully-qualified name.
#[derive(Debug, Default, Clone)]
pub struct UseMap(HashMap<String, String>);

impl UseMap {
    /// Build a UseMap from the `use` statements in a parsed document.
    pub fn from_doc(doc: &ParsedDoc) -> Self {
        let mut map = HashMap::new();
        collect_uses(&doc.program().stmts, &mut map);
        UseMap(map)
    }

    /// Resolve a short name to a FQN, if a matching `use` statement exists.
    pub fn resolve<'a>(&'a self, short: &str) -> Option<&'a str> {
        self.0.get(short).map(|s| s.as_str())
    }
}

fn collect_uses(stmts: &[Stmt<'_, '_>], map: &mut HashMap<String, String>) {
    for stmt in stmts {
        match &stmt.kind {
            StmtKind::Use(u) => {
                for use_item in u.uses.iter() {
                    let fqn = use_item.name.to_string_repr().into_owned();
                    let short = use_item
                        .alias
                        .map(|a| a.to_string())
                        .unwrap_or_else(|| last_segment(&fqn).to_string());
                    map.insert(short, fqn);
                }
            }
            StmtKind::Namespace(ns) => {
                if let NamespaceBody::Braced(inner) = &ns.body {
                    collect_uses(inner, map);
                }
            }
            _ => {}
        }
    }
}

fn last_segment(fqn: &str) -> &str {
    fqn.rsplit('\\').next().unwrap_or(fqn)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolves_simple_use() {
        let src = "<?php\nuse App\\Services\\Mailer;\nclass Foo {}";
        let doc = ParsedDoc::parse(src.to_string());
        let map = UseMap::from_doc(&doc);
        assert_eq!(map.resolve("Mailer"), Some("App\\Services\\Mailer"));
    }

    #[test]
    fn resolves_aliased_use() {
        let src = "<?php\nuse App\\Services\\Mailer as Mail;\nclass Foo {}";
        let doc = ParsedDoc::parse(src.to_string());
        let map = UseMap::from_doc(&doc);
        assert_eq!(map.resolve("Mail"), Some("App\\Services\\Mailer"));
        assert!(map.resolve("Mailer").is_none());
    }

    #[test]
    fn unknown_short_name_returns_none() {
        let src = "<?php\nuse App\\Foo;\n";
        let doc = ParsedDoc::parse(src.to_string());
        let map = UseMap::from_doc(&doc);
        assert!(map.resolve("Bar").is_none());
    }

    #[test]
    fn multiple_use_statements() {
        let src = "<?php\nuse App\\Foo;\nuse App\\Bar;\n";
        let doc = ParsedDoc::parse(src.to_string());
        let map = UseMap::from_doc(&doc);
        assert_eq!(map.resolve("Foo"), Some("App\\Foo"));
        assert_eq!(map.resolve("Bar"), Some("App\\Bar"));
    }

    #[test]
    fn use_inside_namespace_is_collected() {
        let src = "<?php\nnamespace MyNs {\nuse Lib\\Util;\nfunction f() {}\n}";
        let doc = ParsedDoc::parse(src.to_string());
        let map = UseMap::from_doc(&doc);
        assert_eq!(map.resolve("Util"), Some("Lib\\Util"));
    }

    #[test]
    fn empty_file_gives_empty_map() {
        let src = "<?php\nfunction f() {}";
        let doc = ParsedDoc::parse(src.to_string());
        let map = UseMap::from_doc(&doc);
        assert!(map.resolve("Anything").is_none());
    }
}