oak_markdown/
lsp.rs

1use crate::{kind::MarkdownSyntaxKind, language::MarkdownLanguage};
2use core::range::Range;
3use futures::{Future, FutureExt};
4use oak_core::{ElementRole, ElementType, Source, TokenType, tree::RedNode};
5use oak_hover::{Hover as HoverInfo, HoverProvider};
6use oak_lsp::{service::LanguageService, types::Hover as LspHover};
7use oak_vfs::Vfs;
8
9/// Hover provider for Markdown.
10pub struct MarkdownHoverProvider;
11
12impl HoverProvider<MarkdownLanguage> for MarkdownHoverProvider {
13    fn hover(&self, node: &RedNode<'_, MarkdownLanguage>, _range: Range<usize>) -> Option<HoverInfo> {
14        let kind = node.green.kind;
15
16        let contents = match kind {
17            MarkdownSyntaxKind::Heading1 => "### Heading 1\nTop-level heading.",
18            MarkdownSyntaxKind::Heading2 => "### Heading 2\nSecond-level heading.",
19            MarkdownSyntaxKind::Link => "### Markdown Link\nLink to an external resource or internal anchor.",
20            MarkdownSyntaxKind::CodeBlock => "### Code Block\nA block of source code.",
21            MarkdownSyntaxKind::Strong => "### Strong Emphasis\nBold text.",
22            MarkdownSyntaxKind::Emphasis => "### Emphasis\nItalic text.",
23            _ => return None,
24        };
25
26        Some(HoverInfo { contents: contents.to_string(), range: Some(node.span()) })
27    }
28}
29
30pub struct MarkdownLanguageService<V: Vfs> {
31    vfs: V,
32    workspace: oak_lsp::workspace::WorkspaceManager,
33    hover_provider: MarkdownHoverProvider,
34}
35
36impl<V: Vfs> MarkdownLanguageService<V> {
37    pub fn new(vfs: V) -> Self {
38        Self { vfs, workspace: oak_lsp::workspace::WorkspaceManager::new(), hover_provider: MarkdownHoverProvider }
39    }
40
41    fn collect_definitions(&self, node: &RedNode<MarkdownLanguage>, name: &str, source: &str, uri: &str, definitions: &mut Vec<oak_lsp::LocationRange>) {
42        use oak_core::{language::UniversalElementRole, tree::RedTree};
43
44        let role = ElementType::role(&node.green.kind);
45        if ElementRole::universal(&role) == UniversalElementRole::Definition {
46            for child in node.children() {
47                if let RedTree::Leaf(leaf) = child {
48                    if TokenType::is_universal(&leaf.kind, oak_core::language::UniversalTokenRole::Name) {
49                        if &source[leaf.span.clone()] == name {
50                            definitions.push(oak_lsp::LocationRange { uri: uri.into(), range: leaf.span });
51                            return;
52                        }
53                    }
54                }
55            }
56        }
57
58        for child in node.children() {
59            if let RedTree::Node(child_node) = child {
60                self.collect_definitions(&child_node, name, source, uri, definitions);
61            }
62        }
63    }
64}
65
66impl<V: Vfs + Send + Sync + 'static + oak_vfs::WritableVfs> LanguageService for MarkdownLanguageService<V> {
67    type Lang = MarkdownLanguage;
68    type Vfs = V;
69
70    fn vfs(&self) -> &Self::Vfs {
71        &self.vfs
72    }
73
74    fn workspace(&self) -> &oak_lsp::workspace::WorkspaceManager {
75        &self.workspace
76    }
77
78    fn get_root(&self, _uri: &str) -> impl Future<Output = Option<RedNode<'_, MarkdownLanguage>>> + Send + '_ {
79        async move { None }
80    }
81
82    fn definition<'a>(&'a self, uri: &'a str, range: Range<usize>) -> impl Future<Output = Vec<oak_lsp::LocationRange>> + Send + 'a {
83        let uri = uri.to_string();
84        async move {
85            let root = self.get_root(&uri).await?;
86            let source = self.vfs().get_source(&uri)?;
87            let leaf = root.leaf_at_offset(range.start)?;
88
89            if !TokenType::is_universal(&leaf.kind, oak_core::language::UniversalTokenRole::Name) {
90                return None;
91            }
92
93            let name = source.get_text_in(leaf.span.clone());
94            let mut definitions = Vec::new();
95            let full_text = source.get_text_in(Range { start: 0, end: source.length() });
96            self.collect_definitions(&root, &name, &full_text, &uri, &mut definitions);
97            Some(definitions)
98        }
99        .map(|opt| opt.unwrap_or_default())
100    }
101
102    fn references<'a>(&'a self, uri: &'a str, range: Range<usize>) -> impl Future<Output = Vec<oak_lsp::LocationRange>> + Send + 'a {
103        let uri = uri.to_string();
104        async move {
105            let root = self.get_root(&uri).await?;
106            let source = self.vfs().get_source(&uri)?;
107            let leaf = root.leaf_at_offset(range.start)?;
108
109            if !TokenType::is_universal(&leaf.kind, oak_core::language::UniversalTokenRole::Name) {
110                return None;
111            }
112
113            let name = source.get_text_in(leaf.span.clone());
114            let name = name.to_string();
115
116            let mut all_refs = Vec::new();
117            let files = self.list_all_files(&uri).await;
118
119            for file_uri in files {
120                if let Some(file_root) = self.get_root(&file_uri).await {
121                    if let Some(file_source) = self.vfs().get_source(&file_uri) {
122                        let full_text = file_source.get_text_in(Range { start: 0, end: file_source.length() });
123                        let refs = oak_navigation::SimpleReferenceFinder::find(&file_root, &name, &full_text, file_uri.clone());
124                        all_refs.extend(refs.into_iter().map(|l| oak_lsp::LocationRange { uri: l.uri, range: l.range }));
125                    }
126                }
127            }
128
129            Some(all_refs)
130        }
131        .map(|opt| opt.unwrap_or_default())
132    }
133
134    fn rename<'a>(&'a self, uri: &'a str, range: Range<usize>, new_name: String) -> impl Future<Output = Option<oak_lsp::WorkspaceEdit>> + Send + 'a {
135        let uri = uri.to_string();
136        async move {
137            let refs = self.references(&uri, range).await;
138            if refs.is_empty() {
139                return None;
140            }
141
142            let mut changes = std::collections::HashMap::new();
143            for r in refs {
144                changes.entry(r.uri.to_string()).or_insert_with(Vec::new).push(oak_lsp::TextEdit { range: r.range, new_text: new_name.clone() });
145            }
146            Some(oak_lsp::WorkspaceEdit { changes })
147        }
148    }
149
150    fn hover(&self, uri: &str, range: Range<usize>) -> impl Future<Output = Option<LspHover>> + Send + '_ {
151        let uri = uri.to_string();
152        async move { self.with_root(&uri, |root| self.hover_provider.hover(&root, range).map(|h| LspHover { contents: h.contents, range: h.range })).await.flatten() }
153    }
154}
oak_markdown/lsp.rs

oak_markdown/
lsp.rs
