sipha 3.0.0

PEG parser, syntax trees, and code generation
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

//! Collect definition symbols from one or more syntax trees for LSP (document symbols, go-to-def).
//!
//! Grammar-agnostic: the caller supplies an extract callback that returns (name, kind, span)
//! for nodes that represent definitions. The callback receives the current node and the root
//! of the tree being walked (so it can e.g. restrict to top-level symbols).

use std::collections::HashMap;
use std::path::PathBuf;

use crate::tree::red::SyntaxNode;
use crate::tree::walk::{Visitor, WalkOptions, WalkResult};
use crate::types::Span;

/// Collect (name, kind) -> (path, `start_byte`, `end_byte`) from multiple roots.
///
/// For each `(path, root)` the tree is walked; for each node, `extract(node, root)` is called.
/// When it returns `Some((name, kind, span))`, the definition is recorded. First occurrence
/// wins (later duplicates are skipped via `or_insert`).
///
/// `K` is the symbol kind (e.g. an enum: Class, Function, Global). It must be `Eq + Hash`
/// for use as map key.
#[must_use]
pub fn collect_definitions<K: Eq + std::hash::Hash>(
    roots: &[(PathBuf, SyntaxNode)],
    extract: impl Fn(&SyntaxNode, &SyntaxNode) -> Option<(String, K, Span)>,
) -> HashMap<(String, K), (PathBuf, u32, u32)> {
    let mut map = HashMap::new();
    for (path, root) in roots {
        let mut visitor = CollectDefinitionsVisitor {
            path: path.clone(),
            root: root.clone(),
            map: &mut map,
            extract: &extract,
        };
        let _ = root.walk(&mut visitor, &WalkOptions::nodes_only());
    }
    map
}

struct CollectDefinitionsVisitor<'a, K, F> {
    path: PathBuf,
    root: SyntaxNode,
    map: &'a mut HashMap<(String, K), (PathBuf, u32, u32)>,
    extract: &'a F,
}

impl<K: Eq + std::hash::Hash, F: Fn(&SyntaxNode, &SyntaxNode) -> Option<(String, K, Span)>> Visitor
    for CollectDefinitionsVisitor<'_, K, F>
{
    fn enter_node(&mut self, node: &SyntaxNode) -> WalkResult {
        if let Some((name, kind, span)) = (self.extract)(node, &self.root) {
            self.map
                .entry((name, kind))
                .or_insert_with(|| (self.path.clone(), span.start, span.end));
        }
        WalkResult::Continue(())
    }
}