bonsai-ninja-lang-php 0.3.1

PHP language adapter.
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

//! php grammar-owned lexical body boundaries.

use bonsai_lang_api::kit::{lexical_content as body, node_at_span, node_text};
use bonsai_lang_api::{StringCategory, StringLiteral};
use tree_sitter::{Node, Tree};

/// Preserve body-based browse categories when the inventory retains the
/// complete multiline literal, including its opening and closing tags.
pub(super) fn classify_multiline_strings(strings: &mut [StringLiteral], tree: &Tree, src: &[u8]) {
    for literal in strings {
        if !literal.text.starts_with("<<<") {
            continue;
        }
        let Some(node) = node_at_span(tree.root_node(), literal.span, &["heredoc", "nowdoc"]) else {
            continue;
        };
        if !matches!(node.kind(), "heredoc" | "nowdoc")
            || node.has_error()
            || node.start_byte() != literal.span.start as usize
            || node.end_byte() != literal.span.end as usize
        {
            continue;
        }
        literal.category = node
            .child_by_field_name("value")
            .map_or(StringCategory::Generic, |value| {
                StringCategory::classify(node_text(&value, src))
            });
    }
}

pub(super) fn string_content_len(node: Node<'_>, src: &[u8]) -> Option<usize> {
    if node.has_error() {
        return None;
    }
    match node.kind() {
        "heredoc" | "nowdoc" => {
            // The parser-owned body includes its leading newline and excludes
            // the end tag. An absent body denotes an empty heredoc/nowdoc.
            // Select the complete literal: empty nowdocs have no string child.
            node.child_by_field_name("end_tag")?;
            match node.child_by_field_name("value") {
                Some(content) => body::count(src, content.start_byte(), content.end_byte()),
                None => Some(0),
            }
        }
        "string" | "encapsed_string" => {
            // PHP's binary prefix/opening quote can be hidden by the grammar.
            let text = node_text(&node, src);
            let quoted = text
                .strip_prefix('b')
                .or_else(|| text.strip_prefix('B'))
                .unwrap_or(text);
            let quote = match quoted.as_bytes().first()? {
                b'\'' => "'",
                b'"' => "\"",
                _ => return None,
            };
            body::delimited(quoted, quote, quote)
        }
        _ => None,
    }
}

pub(super) fn comment_content_len(node: Node<'_>, src: &[u8]) -> Option<usize> {
    if node.has_error() {
        return None;
    }
    let text = node_text(&node, src);
    if text.starts_with("/*") {
        // /**/ is an empty block, with overlapping doc/closing spellings.
        let opening = if text.starts_with("/**") && text.len() > 4 {
            "/**"
        } else {
            "/*"
        };
        return body::delimited(text, opening, "*/");
    }
    let opening = ["//", "#"].into_iter().find(|prefix| text.starts_with(prefix))?;
    body::delimited(text, opening, "")
}