tinymist-query 0.15.0-rc1

Language queries for tinymist.
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::sync::OnceLock;

use ecow::EcoString;
use tinymist_analysis::Signature;
use tinymist_analysis::docs::tidy::remove_list_annotations;
use tinymist_analysis::docs::{
    DocText, DocTextResolver, ParamDocs, SignatureDocs, VarDocs, format_ty,
};
use tinymist_analysis::ty::DocSource;
use typst::syntax::Span;

use crate::LocalContext;
use crate::analysis::SharedContext;

pub(crate) fn var_docs(ctx: &mut LocalContext, pos: Span) -> Option<VarDocs> {
    let source = ctx.source_by_id(pos.id()?).ok()?;
    let type_info = ctx.type_check(&source);
    let ty = type_info.type_of_span(pos)?;

    // todo multiple sources
    // Must use raw result as type aliases contain the source information.
    let mut srcs = ty.sources();
    srcs.sort();
    log::debug!("check variable docs of ty: {ty:?} => {srcs:?}");
    let doc_source = srcs.into_iter().next()?;

    // todo people can easily forget to simplify the type which is not good. we
    // might find a way to ensure them at compile time.
    //
    // Must be simplified before formatting, to expand type aliases.
    let simplified_ty = type_info.simplify(ty, false);
    let return_ty = format_ty(Some(&simplified_ty));
    match doc_source {
        DocSource::Var(var) => {
            let docs = type_info
                .var_docs
                .get(&var.def)
                .map(|docs| docs.docs().clone());
            Some(VarDocs {
                docs: docs.unwrap_or_default(),
                return_ty,
                def_docs: OnceLock::new(),
            })
        }
        DocSource::Ins(ins) => ins.syntax.as_ref().map(|src| {
            let docs = convert_typst_docs(ctx, src.doc.as_ref().into());
            VarDocs {
                docs,
                return_ty,
                def_docs: OnceLock::new(),
            }
        }),
        _ => None,
    }
}

pub(crate) fn sig_docs(ctx: &mut LocalContext, sig: &Signature) -> Option<SignatureDocs> {
    let type_sig = sig.type_sig().clone();

    let pos_in = sig
        .primary()
        .pos()
        .iter()
        .enumerate()
        .map(|(idx, pos)| (pos, type_sig.pos(idx)));
    let named_in = sig
        .primary()
        .named()
        .iter()
        .map(|param| (param, type_sig.named(&param.name)));
    let rest_in = sig.primary().rest().map(|x| (x, type_sig.rest_param()));

    let ret_in = type_sig.body.as_ref();

    let pos = pos_in
        .map(|(param, ty)| ParamDocs::new(ctx, param, ty))
        .collect::<Vec<_>>();
    let named = named_in
        .map(|(param, ty)| (param.name.clone(), ParamDocs::new(ctx, param, ty)))
        .collect::<std::collections::BTreeMap<_, _>>();
    let rest = rest_in.map(|(param, ty)| ParamDocs::new(ctx, param, ty));

    let ret_ty = format_ty(ret_in);

    let docs = sig
        .primary()
        .docs
        .as_ref()
        .map(|docs| resolve_doc_text(ctx, docs))
        .unwrap_or_default();

    Some(SignatureDocs {
        docs,
        pos,
        named,
        rest,
        ret_ty,
        hover_docs: OnceLock::new(),
    })
}

pub(crate) fn resolve_doc_text(ctx: &mut LocalContext, docs: &DocText) -> EcoString {
    let shared = ctx.shared();
    docs.get_or_init(|raw| convert_official_doc(shared, raw.clone()))
        .clone()
}

impl DocTextResolver for LocalContext {
    fn resolve_doc_text(&mut self, docs: &DocText) -> EcoString {
        resolve_doc_text(self, docs)
    }
}

fn convert_official_doc(ctx: &SharedContext, docs: EcoString) -> EcoString {
    if docs.trim().is_empty() {
        return docs;
    }

    let docs_text = DocText::official(docs.clone());
    match crate::docs::convert_docs(ctx, &docs_text, None) {
        Ok(converted) => {
            let converted = remove_list_annotations(&converted);
            ctx.remove_html(converted.trim().into())
        }
        Err(err) => {
            log::warn!("failed to convert official Typst docs to Markdown: {err}");
            ctx.remove_html(docs)
        }
    }
}

pub(crate) fn convert_typst_docs(ctx: &mut LocalContext, docs: EcoString) -> EcoString {
    if docs.trim().is_empty() {
        return docs;
    }

    let shared = ctx.shared_();
    let docs_text = DocText::plain(docs.clone());
    match crate::docs::convert_docs(&shared, &docs_text, None) {
        Ok(converted) => {
            let converted = remove_list_annotations(&converted);
            ctx.remove_html(converted.trim().into())
        }
        Err(err) => {
            log::warn!("failed to convert Typst docs to Markdown: {err}");
            ctx.remove_html(docs)
        }
    }
}