ginko 0.0.4

A device-tree source parser and analyzer
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

use crate::dts::analysis::AnalysisContext;
use crate::dts::ast::{DtsFile, Reference};
use crate::dts::lexer::Lexer;
use crate::dts::reader::ByteReader;
use crate::dts::visitor::ItemAtCursor;
use crate::dts::{Analysis, Diagnostic, FileType, HasSpan, Parser, Position, Span};
use std::collections::HashMap;
use url::Url;

struct ProjectFile {
    diagnostics: Vec<Diagnostic>,
    file: Option<DtsFile>,
    context: Option<AnalysisContext>,
}

#[derive(Default)]
pub struct Project {
    files: HashMap<Url, ProjectFile>,
}

static NO_DIAGNOSTICS: Vec<Diagnostic> = Vec::new();

impl Project {
    pub fn add_file(&mut self, url: Url, text: String, file_type: FileType) {
        let (diagnostics, file, context) = analyze_text(text.clone(), file_type);
        self.files.insert(
            url.clone(),
            ProjectFile {
                diagnostics,
                file,
                context,
            },
        );
    }

    pub fn remove_file(&mut self, url: &Url) {
        self.files.remove(url);
    }

    pub fn get_diagnostics(&self, url: &Url) -> &[Diagnostic] {
        self.files
            .get(url)
            .map(|file| &file.diagnostics)
            .unwrap_or(&NO_DIAGNOSTICS)
    }

    pub fn get_analysis(&self, url: &Url) -> Option<&AnalysisContext> {
        match self.files.get(url) {
            None => None,
            Some(project) => project.context.as_ref(),
        }
    }

    pub fn find_at_pos<'a>(&'a self, url: &Url, position: &Position) -> Option<ItemAtCursor<'a>> {
        let file = match self.files.get(url).and_then(|file| file.file.as_ref()) {
            None => return None,
            Some(file) => file,
        };
        file.item_at_cursor(position)
    }

    pub fn document_reference(&self, uri: &Url, reference: &Reference) -> Option<String> {
        let Some(analysis) = self.get_analysis(uri) else {
            return None;
        };
        let Some(referenced) = analysis.get_referenced(reference) else {
            return None;
        };
        Some(format!("Node {}", referenced.name.name.clone()))
    }

    pub fn get_node_position(&self, uri: &Url, reference: &Reference) -> Option<Span> {
        let Some(analysis) = self.get_analysis(uri) else {
            return None;
        };
        let Some(referenced) = analysis.get_referenced(reference) else {
            return None;
        };
        Some(referenced.name.span())
    }

    pub fn get_root(&self, uri: &Url) -> Option<&DtsFile> {
        match self.files.get(uri) {
            Some(ProjectFile {
                file: Some(file), ..
            }) => Some(file),
            _ => None,
        }
    }
}

fn analyze_text(
    text: String,
    file_type: FileType,
) -> (Vec<Diagnostic>, Option<DtsFile>, Option<AnalysisContext>) {
    let reader = ByteReader::from_string(text);
    let lexer = Lexer::new(reader);
    let mut parser = Parser::new(lexer);
    match parser.file() {
        Ok(file) => {
            let mut analysis = Analysis::new(file_type);
            analysis.analyze_file(&mut parser.diagnostics, &file);
            (
                parser.diagnostics,
                Some(file),
                Some(analysis.into_context()),
            )
        }
        Err(err) => (vec![err], None, None),
    }
}