language-servers/tinymist
1
0
Fork 0
mirror of https://github.com/Myriad-Dreamin/tinymist.git synced 2025-07-24 13:13:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

feat: associate request function

Browse source
This commit is contained in:
Myriad-Dreamin 2024-03-07 16:31:16 +08:00
parent 0c7e67ed9a
commit 50ca444915
9 changed files with 215 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

31
crates/tinymist-query/src/completion.rs
View file

@ -7,20 +7,23 @@ pub struct CompletionRequest {
pub explicit: bool,
}
pub fn completion(
world: &TypstSystemWorld,
doc: Option<Arc<TypstDocument>>,
req: CompletionRequest,
position_encoding: PositionEncoding,
) -> Option<CompletionResponse> {
let source = get_suitable_source_in_workspace(world, &req.path).ok()?;
let typst_offset = lsp_to_typst::position_to_offset(req.position, position_encoding, &source);
impl CompletionRequest {
pub fn request(
self,
world: &TypstSystemWorld,
doc: Option<Arc<TypstDocument>>,
position_encoding: PositionEncoding,
) -> Option<CompletionResponse> {
let source = get_suitable_source_in_workspace(world, &self.path).ok()?;
let typst_offset =
lsp_to_typst::position_to_offset(self.position, position_encoding, &source);
let (typst_start_offset, completions) =
typst_ide::autocomplete(world, doc.as_deref(), &source, typst_offset, req.explicit)?;
let (typst_start_offset, completions) =
typst_ide::autocomplete(world, doc.as_deref(), &source, typst_offset, self.explicit)?;
let lsp_start_position =
typst_to_lsp::offset_to_position(typst_start_offset, position_encoding, &source);
let replace_range = LspRawRange::new(lsp_start_position, req.position);
Some(typst_to_lsp::completions(&completions, replace_range).into())
let lsp_start_position =
typst_to_lsp::offset_to_position(typst_start_offset, position_encoding, &source);
let replace_range = LspRawRange::new(lsp_start_position, self.position);
Some(typst_to_lsp::completions(&completions, replace_range).into())
}
}

20
crates/tinymist-query/src/document_symbol.rs
View file

@ -5,17 +5,19 @@ pub struct DocumentSymbolRequest {
pub path: PathBuf,
}
pub fn document_symbol(
world: &TypstSystemWorld,
req: DocumentSymbolRequest,
position_encoding: PositionEncoding,
) -> Option<DocumentSymbolResponse> {
let source = get_suitable_source_in_workspace(world, &req.path).ok()?;
impl DocumentSymbolRequest {
pub fn request(
self,
world: &TypstSystemWorld,
position_encoding: PositionEncoding,
) -> Option<DocumentSymbolResponse> {
let source = get_suitable_source_in_workspace(world, &self.path).ok()?;
let uri = Url::from_file_path(req.path).unwrap();
let symbols = get_document_symbols(source, uri, position_encoding);
let uri = Url::from_file_path(self.path).unwrap();
let symbols = get_document_symbols(source, uri, position_encoding);
symbols.map(DocumentSymbolResponse::Flat)
symbols.map(DocumentSymbolResponse::Flat)
}
}
#[comemo::memoize]

33
crates/tinymist-query/src/hover.rs
View file

@ -6,22 +6,25 @@ pub struct HoverRequest {
pub position: LspPosition,
}
pub fn hover(
world: &TypstSystemWorld,
doc: Option<Arc<TypstDocument>>,
req: HoverRequest,
position_encoding: PositionEncoding,
) -> Option<Hover> {
let source = get_suitable_source_in_workspace(world, &req.path).ok()?;
let typst_offset = lsp_to_typst::position_to_offset(req.position, position_encoding, &source);
impl HoverRequest {
pub fn request(
self,
world: &TypstSystemWorld,
doc: Option<Arc<TypstDocument>>,
position_encoding: PositionEncoding,
) -> Option<Hover> {
let source = get_suitable_source_in_workspace(world, &self.path).ok()?;
let typst_offset =
lsp_to_typst::position_to_offset(self.position, position_encoding, &source);
let typst_tooltip = typst_ide::tooltip(world, doc.as_deref(), &source, typst_offset)?;
let typst_tooltip = typst_ide::tooltip(world, doc.as_deref(), &source, typst_offset)?;
let ast_node = LinkedNode::new(source.root()).leaf_at(typst_offset)?;
let range = typst_to_lsp::range(ast_node.range(), &source, position_encoding);
let ast_node = LinkedNode::new(source.root()).leaf_at(typst_offset)?;
let range = typst_to_lsp::range(ast_node.range(), &source, position_encoding);
Some(Hover {
contents: typst_to_lsp::tooltip(&typst_tooltip),
range: Some(range.raw_range),
})
Some(Hover {
contents: typst_to_lsp::tooltip(&typst_tooltip),
range: Some(range.raw_range),
})
}
}

31
crates/tinymist-query/src/selection_range.rs
View file

@ -6,22 +6,25 @@ pub struct SelectionRangeRequest {
pub positions: Vec<LspPosition>,
}
pub fn selection_range(
world: &TypstSystemWorld,
req: SelectionRangeRequest,
position_encoding: PositionEncoding,
) -> Option<Vec<SelectionRange>> {
let source = get_suitable_source_in_workspace(world, &req.path).ok()?;
impl SelectionRangeRequest {
pub fn request(
self,
world: &TypstSystemWorld,
position_encoding: PositionEncoding,
) -> Option<Vec<SelectionRange>> {
let source = get_suitable_source_in_workspace(world, &self.path).ok()?;
let mut ranges = Vec::new();
for position in req.positions {
let typst_offset = lsp_to_typst::position_to_offset(position, position_encoding, &source);
let tree = LinkedNode::new(source.root());
let leaf = tree.leaf_at(typst_offset)?;
ranges.push(range_for_node(&source, position_encoding, &leaf));
let mut ranges = Vec::new();
for position in self.positions {
let typst_offset =
lsp_to_typst::position_to_offset(position, position_encoding, &source);
let tree = LinkedNode::new(source.root());
let leaf = tree.leaf_at(typst_offset)?;
ranges.push(range_for_node(&source, position_encoding, &leaf));
}
Some(ranges)
}
Some(ranges)
}
fn range_for_node(

54
crates/tinymist-query/src/semantic_tokens_delta.rs
View file

@ -6,32 +6,34 @@ pub struct SemanticTokensDeltaRequest {
pub previous_result_id: String,
}
pub fn semantic_tokens_delta(
cache: &SemanticTokenCache,
source: Source,
req: SemanticTokensDeltaRequest,
position_encoding: PositionEncoding,
) -> Option<SemanticTokensFullDeltaResult> {
let (tokens, result_id) = cache.try_semantic_tokens_delta_from_result_id(
&source,
&req.previous_result_id,
position_encoding,
);
impl SemanticTokensDeltaRequest {
pub fn request(
self,
cache: &SemanticTokenCache,
source: Source,
position_encoding: PositionEncoding,
) -> Option<SemanticTokensFullDeltaResult> {
let (tokens, result_id) = cache.try_semantic_tokens_delta_from_result_id(
&source,
&self.previous_result_id,
position_encoding,
);
match tokens {
Ok(edits) => Some(
SemanticTokensDelta {
result_id: Some(result_id),
edits,
}
.into(),
),
Err(tokens) => Some(
SemanticTokens {
result_id: Some(result_id),
data: tokens,
}
.into(),
),
match tokens {
Ok(edits) => Some(
SemanticTokensDelta {
result_id: Some(result_id),
edits,
}
.into(),
),
Err(tokens) => Some(
SemanticTokens {
result_id: Some(result_id),
data: tokens,
}
.into(),
),
}
}
}

30
crates/tinymist-query/src/semantic_tokens_full.rs
View file

@ -5,19 +5,21 @@ pub struct SemanticTokensFullRequest {
pub path: PathBuf,
}
pub fn semantic_tokens_full(
cache: &SemanticTokenCache,
source: Source,
_req: SemanticTokensFullRequest,
position_encoding: PositionEncoding,
) -> Option<SemanticTokensResult> {
let (tokens, result_id) = cache.get_semantic_tokens_full(&source, position_encoding);
impl SemanticTokensFullRequest {
pub fn request(
self,
cache: &SemanticTokenCache,
source: Source,
position_encoding: PositionEncoding,
) -> Option<SemanticTokensResult> {
let (tokens, result_id) = cache.get_semantic_tokens_full(&source, position_encoding);
Some(
SemanticTokens {
result_id: Some(result_id),
data: tokens,
}
.into(),
)
Some(
SemanticTokens {
result_id: Some(result_id),
data: tokens,
}
.into(),
)
}
}

125
crates/tinymist-query/src/signature_help.rs
View file

@ -6,73 +6,76 @@ pub struct SignatureHelpRequest {
pub position: LspPosition,
}
pub fn signature_help(
world: &TypstSystemWorld,
SignatureHelpRequest { path, position }: SignatureHelpRequest,
position_encoding: PositionEncoding,
) -> Option<SignatureHelp> {
let source = get_suitable_source_in_workspace(world, &path).ok()?;
let typst_offset = lsp_to_typst::position_to_offset(position, position_encoding, &source);
impl SignatureHelpRequest {
pub fn request(
self,
world: &TypstSystemWorld,
position_encoding: PositionEncoding,
) -> Option<SignatureHelp> {
let source = get_suitable_source_in_workspace(world, &self.path).ok()?;
let typst_offset =
lsp_to_typst::position_to_offset(self.position, position_encoding, &source);
let ast_node = LinkedNode::new(source.root()).leaf_at(typst_offset)?;
let (callee, callee_node, args) = surrounding_function_syntax(&ast_node)?;
let ast_node = LinkedNode::new(source.root()).leaf_at(typst_offset)?;
let (callee, callee_node, args) = surrounding_function_syntax(&ast_node)?;
let mut ancestor = &ast_node;
while !ancestor.is::<ast::Expr>() {
ancestor = ancestor.parent()?;
}
if !callee.hash() && !matches!(callee, ast::Expr::MathIdent(_)) {
return None;
}
let values = analyze_expr(world, &callee_node);
let function = values.into_iter().find_map(|v| match v {
Value::Func(f) => Some(f),
_ => None,
})?;
trace!("got function {function:?}");
let param_index = param_index_at_leaf(&ast_node, &function, args);
let label = format!(
"{}({}){}",
function.name().unwrap_or("<anonymous closure>"),
match function.params() {
Some(params) => params
.iter()
.map(typst_to_lsp::param_info_to_label)
.join(", "),
None => "".to_owned(),
},
match function.returns() {
Some(returns) => format!("-> {}", typst_to_lsp::cast_info_to_label(returns)),
None => "".to_owned(),
let mut ancestor = &ast_node;
while !ancestor.is::<ast::Expr>() {
ancestor = ancestor.parent()?;
}
);
let params = function
.params()
.unwrap_or_default()
.iter()
.map(typst_to_lsp::param_info)
.collect();
trace!("got signature info {label} {params:?}");
let documentation = function.docs().map(markdown_docs);
if !callee.hash() && !matches!(callee, ast::Expr::MathIdent(_)) {
return None;
}
let active_parameter = param_index.map(|i| i as u32);
let values = analyze_expr(world, &callee_node);
Some(SignatureHelp {
signatures: vec![SignatureInformation {
label,
documentation,
parameters: Some(params),
active_parameter,
}],
active_signature: Some(0),
active_parameter: None,
})
let function = values.into_iter().find_map(|v| match v {
Value::Func(f) => Some(f),
_ => None,
})?;
trace!("got function {function:?}");
let param_index = param_index_at_leaf(&ast_node, &function, args);
let label = format!(
"{}({}){}",
function.name().unwrap_or("<anonymous closure>"),
match function.params() {
Some(params) => params
.iter()
.map(typst_to_lsp::param_info_to_label)
.join(", "),
None => "".to_owned(),
},
match function.returns() {
Some(returns) => format!("-> {}", typst_to_lsp::cast_info_to_label(returns)),
None => "".to_owned(),
}
);
let params = function
.params()
.unwrap_or_default()
.iter()
.map(typst_to_lsp::param_info)
.collect();
trace!("got signature info {label} {params:?}");
let documentation = function.docs().map(markdown_docs);
let active_parameter = param_index.map(|i| i as u32);
Some(SignatureHelp {
signatures: vec![SignatureInformation {
label,
documentation,
parameters: Some(params),
active_parameter,
}],
active_signature: Some(0),
active_parameter: None,
})
}
}
fn surrounding_function_syntax<'b>(

46
crates/tinymist-query/src/symbol.rs
View file

@ -8,32 +8,34 @@ pub struct SymbolRequest {
pub pattern: Option<String>,
}
pub fn symbol(
world: &TypstSystemWorld,
SymbolRequest { pattern }: SymbolRequest,
position_encoding: PositionEncoding,
) -> Option<Vec<SymbolInformation>> {
// todo: expose source
impl SymbolRequest {
pub fn request(
self,
world: &TypstSystemWorld,
position_encoding: PositionEncoding,
) -> Option<Vec<SymbolInformation>> {
// todo: expose source
let mut symbols = vec![];
let mut symbols = vec![];
world.iter_dependencies(&mut |path, _| {
let Ok(source) = get_suitable_source_in_workspace(world, path) else {
return;
};
let uri = Url::from_file_path(path).unwrap();
let res = get_document_symbols(source, uri, position_encoding).and_then(|symbols| {
pattern
.as_ref()
.map(|pattern| filter_document_symbols(symbols, pattern))
world.iter_dependencies(&mut |path, _| {
let Ok(source) = get_suitable_source_in_workspace(world, path) else {
return;
};
let uri = Url::from_file_path(path).unwrap();
let res = get_document_symbols(source, uri, position_encoding).and_then(|symbols| {
self.pattern
.as_ref()
.map(|pattern| filter_document_symbols(symbols, pattern))
});
if let Some(mut res) = res {
symbols.append(&mut res)
}
});
if let Some(mut res) = res {
symbols.append(&mut res)
}
});
Some(symbols)
Some(symbols)
}
}
fn filter_document_symbols(

51
crates/tinymist/src/actor/typst.rs
View file

@ -7,7 +7,9 @@ use std::{
use anyhow::anyhow;
use futures::future::join_all;
use log::{error, trace, warn};
use tinymist_query::{LspDiagnostic, LspRange, PositionEncoding, SemanticTokenCache};
use tinymist_query::{
DiagnosticsMap, LspDiagnostic, LspRange, PositionEncoding, SemanticTokenCache,
};
use tokio::sync::{broadcast, mpsc, watch, Mutex, RwLock};
use tower_lsp::lsp_types::{
CompletionResponse, DocumentSymbolResponse, Hover, SelectionRange,
@ -42,9 +44,6 @@ type CompileService<H> = CompileActor<Reporter<CompileExporter<CompileDriver>, H
type CompileClient<H> = TsCompileClient<CompileService<H>>;
type DiagnosticsSender = mpsc::UnboundedSender<(String, DiagnosticsMap)>;
type DiagnosticsMap = HashMap<Url, Vec<LspDiagnostic>>;
// type Client = TypstClient<CompileHandler>;
pub struct CompileCluster {
position_encoding: PositionEncoding,
@ -65,7 +64,7 @@ pub fn create_cluster(
let primary = create_server(
"primary".to_owned(),
cfg,
create_compiler(roots.clone(), opts.clone()),
CompileDriver::new(roots.clone(), opts.clone()),
diag_tx,
);
@ -83,11 +82,6 @@ pub fn create_cluster(
}
}
fn create_compiler(roots: Vec<PathBuf>, opts: CompileOpts) -> CompileDriver {
let world = TypstSystemWorld::new(opts).expect("incorrect options");
CompileDriver::new(world, roots)
}
fn create_server(
diag_group: String,
cfg: &ConstConfig,
@ -323,31 +317,31 @@ pub enum CompilerQueryResponse {
}
macro_rules! query_state {
($self:ident, $method:ident, $query:expr, $req:expr) => {{
($self:ident, $method:ident, $req:expr) => {{
let doc = $self.handler.result.lock().unwrap().clone().ok();
let enc = $self.position_encoding;
let res = $self.steal_world(move |w| $query(w, doc, $req, enc)).await;
let res = $self.steal_world(move |w| $req.request(w, doc, enc)).await;
res.map(CompilerQueryResponse::$method)
}};
}
macro_rules! query_world {
($self:ident, $method:ident, $query:expr, $req:expr) => {{
($self:ident, $method:ident, $req:expr) => {{
let enc = $self.position_encoding;
let res = $self.steal_world(move |w| $query(w, $req, enc)).await;
let res = $self.steal_world(move |w| $req.request(w, enc)).await;
res.map(CompilerQueryResponse::$method)
}};
}
macro_rules! query_tokens_cache {
($self:ident, $method:ident, $query:expr, $req:expr) => {{
($self:ident, $method:ident, $req:expr) => {{
let path: ImmutPath = $req.path.clone().into();
let vfs = $self.memory_changes.read().await;
let snapshot = vfs.get(&path).ok_or_else(|| anyhow!("file missing"))?;
let source = snapshot.content.clone();
let enc = $self.position_encoding;
let res = $query(&$self.tokens_cache, source, $req, enc);
let res = $req.request(&$self.tokens_cache, source, enc);
Ok(CompilerQueryResponse::$method(res))
}};
}
@ -357,16 +351,11 @@ impl CompileCluster {
&self,
query: CompilerQueryRequest,
) -> anyhow::Result<CompilerQueryResponse> {
use tinymist_query::*;
use CompilerQueryRequest::*;
match query {
SemanticTokensFull(req) => {
query_tokens_cache!(self, SemanticTokensFull, semantic_tokens_full, req)
}
SemanticTokensDelta(req) => {
query_tokens_cache!(self, SemanticTokensDelta, semantic_tokens_delta, req)
}
SemanticTokensFull(req) => query_tokens_cache!(self, SemanticTokensFull, req),
SemanticTokensDelta(req) => query_tokens_cache!(self, SemanticTokensDelta, req),
_ => self.primary.query(query).await,
}
}
@ -415,7 +404,8 @@ impl CompileMiddleware for CompileDriver {
}
impl CompileDriver {
fn new(world: TypstSystemWorld, roots: Vec<PathBuf>) -> Self {
fn new(roots: Vec<PathBuf>, opts: CompileOpts) -> Self {
let world = TypstSystemWorld::new(opts).expect("incorrect options");
let driver = CompileDriverInner::new(world);
Self {
@ -679,7 +669,6 @@ impl<H: CompilationHandle> CompileNode<H> {
&self,
query: CompilerQueryRequest,
) -> anyhow::Result<CompilerQueryResponse> {
use tinymist_query::*;
use CompilerQueryRequest::*;
match query {
@ -687,12 +676,12 @@ impl<H: CompilationHandle> CompileNode<H> {
self.on_save_export(path).await?;
Ok(CompilerQueryResponse::OnSaveExport(()))
}
Hover(req) => query_state!(self, Hover, hover, req),
Completion(req) => query_state!(self, Completion, completion, req),
SignatureHelp(req) => query_world!(self, SignatureHelp, signature_help, req),
DocumentSymbol(req) => query_world!(self, DocumentSymbol, document_symbol, req),
Symbol(req) => query_world!(self, Symbol, symbol, req),
SelectionRange(req) => query_world!(self, SelectionRange, selection_range, req),
Hover(req) => query_state!(self, Hover, req),
Completion(req) => query_state!(self, Completion, req),
SignatureHelp(req) => query_world!(self, SignatureHelp, req),
DocumentSymbol(req) => query_world!(self, DocumentSymbol, req),
Symbol(req) => query_world!(self, Symbol, req),
SelectionRange(req) => query_world!(self, SelectionRange, req),
CompilerQueryRequest::SemanticTokensDelta(..)
| CompilerQueryRequest::SemanticTokensFull(..) => unreachable!(),
}