yggdrasil-shared 0.2.5

Yggdrasil Compiler core shared components
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

pub use self::{file_store::FileStore, file_wrap::FileType, finger_print::FileFingerprint};
use crate::{
    frontend::{GrammarContext, GrammarInfo, GrammarType, Translator},
    manager::{global_parser::PARSER_MANAGER, HintItems},
    Result, YggdrasilError, HINT_MANAGER,
};
use dashmap::{mapref::one::Ref, DashMap};
use lsp_types::{Diagnostic, Url};
use std::{fs, lazy::SyncLazy, path::Path};
use xxhash_rust::xxh3::xxh3_128;

mod file_store;
mod file_wrap;
mod finger_print;

pub static FILE_MANAGER: SyncLazy<FileManager> = SyncLazy::new(|| FileManager::default());

//#[derive(Archive, Deserialize, Serialize, Debug, PartialEq)]
pub struct FileManager {
    store: DashMap<Url, FileStore>,
}

impl Default for FileManager {
    fn default() -> Self {
        Self { store: Default::default() }
    }
}

impl FileManager {
    pub fn load_cache(&self, _path: impl AsRef<Path>) -> Result<()> {
        unimplemented!()
    }
    pub fn save_cache(&self, _path: impl AsRef<Path>) -> Result<()> {
        unimplemented!()
    }

    pub fn update_url(&self, url: Url) -> Result<()> {
        let new = FileFingerprint::new(&url)?;
        match self.store.get(&url) {
            Some(old) if old.eq(&new) => return Ok(()),
            _ => (),
        }
        let file = FileStore::load_url(&url, new)?;
        self.store.insert(url, file);
        Ok(())
    }
    pub fn update_url_text(&self, url: Url, text: String) -> Result<()> {
        let new = FileFingerprint::new(&url)?;
        match self.store.get(&url) {
            Some(old) if old.eq(&new) => return Ok(()),
            _ => (),
        }
        let file = match url.to_file_path()?.extension().and_then(|e| e.to_str()) {
            Some("toml") => Ok(FileStore::new_type(new.fingerprint, text)),
            Some("ygg") | Some("yg") => Ok(FileStore::new_grammar(new.fingerprint, text)),
            _ => Err(QError::language_error("Unsupported file extension")),
        }?;
        self.store.insert(url, file);
        Ok(())
    }
    #[inline]
    pub fn get_file(&self, url: &Url) -> Option<Ref<'_, Url, FileStore>> {
        self.store.get(&url)
    }
    pub fn get_symbol(&self, url: &Url, _symbol: &str) -> Result<()> {
        let _f = self.get_file(url);
        unimplemented!()
    }
    pub fn get_type(&self, _ty: &str) -> Result<()> {
        unimplemented!()
    }
}

impl FileManager {
    pub async fn parse_file(&self, url: &Url) -> Result<Ref<'_, Url, FileStore>> {
        match url.to_file_path()?.extension().and_then(|e| e.to_str()) {
            Some("toml") => {
                self.parse_type(url).await?;
                Ok(())
            }
            Some("ygg") | Some("yg") => {
                self.parse_grammar(url).await?;
                Ok(())
            }
            _ => Err(QError::language_error("Unsupported file extension")),
        }?;
        match self.get_file(url) {
            Some(s) => Ok(s),
            None => Err(QError::unreachable()),
        }
    }

    pub async fn parse_type(&self, _url: &Url) -> Result<&GrammarType> {
        unimplemented!()
    }

    pub async fn parse_grammar(&self, url: &Url) -> Result<GrammarInfo> {
        self.update_url(url.to_owned())?;
        self.store
            .get_mut(url)
            .ok_or(QError::language_error("Grammar not found"))?
            .value_mut()
            .parse_ygg(url.to_owned())
            .await
    }
}