oak_tex/builder/
mod.rs

1use crate::{ast::*, language::TexLanguage, lexer::token_type::TexTokenType, parser::TexParser};
2use oak_core::{Builder, BuilderCache, GreenNode, OakDiagnostics, OakError, Parser, RedNode, RedTree, TextEdit, source::Source};
3
4/// An AST builder for the TeX language.
5#[derive(Clone)]
6pub struct TexBuilder<'config> {
7    /// The language configuration.
8    config: &'config TexLanguage,
9}
10
11impl<'config> TexBuilder<'config> {
12    /// Creates a new TeX builder.
13    pub fn new(config: &'config TexLanguage) -> Self {
14        Self { config }
15    }
16}
17
18impl<'config> Builder<TexLanguage> for TexBuilder<'config> {
19    fn build<'a, S: Source + ?Sized>(&self, source: &'a S, edits: &[TextEdit], cache: &'a mut impl BuilderCache<TexLanguage>) -> oak_core::builder::BuildOutput<TexLanguage> {
20        let parser = TexParser::new(self.config);
21
22        let parse_result = parser.parse(source, edits, cache);
23
24        match parse_result.result {
25            Ok(green_tree) => match self.build_root_internal(green_tree, source) {
26                Ok(ast_root) => OakDiagnostics { result: Ok(ast_root), diagnostics: parse_result.diagnostics },
27                Err(build_error) => {
28                    let mut diagnostics = parse_result.diagnostics;
29                    diagnostics.push(build_error.clone());
30                    OakDiagnostics { result: Err(build_error), diagnostics }
31                }
32            },
33            Err(parse_error) => OakDiagnostics { result: Err(parse_error), diagnostics: parse_result.diagnostics },
34        }
35    }
36}
37
38impl<'config> TexBuilder<'config> {
39    /// Builds the root node of the TeX AST.
40    fn build_root_internal<S: Source + ?Sized>(&self, green_tree: &GreenNode<TexLanguage>, source: &S) -> Result<TexRoot, OakError> {
41        let red_root = RedNode::new(green_tree, 0);
42        self.build_content(red_root, source)
43    }
44
45    /// Builds the content of a node into a `TexRoot`.
46    fn build_content<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexRoot, OakError> {
47        let mut items = Vec::new();
48        let children: Vec<_> = node.children().collect();
49
50        if children.is_empty() {
51            return Ok(TexRoot { span: node.span().into(), items });
52        }
53
54        let first_kind: TexTokenType = children.first().unwrap().kind();
55        let last_kind: TexTokenType = children.last().unwrap().kind();
56
57        let start = if is_delimiter(first_kind) { 1 } else { 0 };
58        let end = if children.len() > start && is_delimiter(last_kind) { children.len() - 1 } else { children.len() };
59
60        for i in start..end {
61            if let Some(item) = self.build_item(children[i], source)? {
62                items.push(item)
63            }
64        }
65
66        Ok(TexRoot { span: node.span().into(), items })
67    }
68
69    fn build_item<S: Source + ?Sized>(&self, tree: RedTree<TexLanguage>, source: &S) -> Result<Option<TexItem>, OakError> {
70        let kind: TexTokenType = tree.kind();
71        match kind {
72            TexTokenType::Command
73            | TexTokenType::BeginKeyword
74            | TexTokenType::EndKeyword
75            | TexTokenType::Frac
76            | TexTokenType::Sqrt
77            | TexTokenType::Sum
78            | TexTokenType::Int
79            | TexTokenType::Lim
80            | TexTokenType::SectionKeyword
81            | TexTokenType::SubsectionKeyword
82            | TexTokenType::SubsubsectionKeyword
83            | TexTokenType::ChapterKeyword
84            | TexTokenType::PartKeyword
85            | TexTokenType::TitleKeyword
86            | TexTokenType::AuthorKeyword
87            | TexTokenType::DateKeyword
88            | TexTokenType::MaketitleKeyword
89            | TexTokenType::TableofcontentsKeyword
90            | TexTokenType::ItemKeyword
91            | TexTokenType::LabelKeyword
92            | TexTokenType::RefKeyword
93            | TexTokenType::CiteKeyword
94            | TexTokenType::IncludegraphicsKeyword
95            | TexTokenType::TextbfKeyword
96            | TexTokenType::TextitKeyword
97            | TexTokenType::EmphKeyword
98            | TexTokenType::Alpha
99            | TexTokenType::Beta
100            | TexTokenType::Gamma
101            | TexTokenType::Delta
102            | TexTokenType::Epsilon
103            | TexTokenType::Zeta
104            | TexTokenType::Eta
105            | TexTokenType::Theta
106            | TexTokenType::Iota
107            | TexTokenType::Kappa
108            | TexTokenType::Lambda
109            | TexTokenType::Mu
110            | TexTokenType::Nu
111            | TexTokenType::Xi
112            | TexTokenType::Omicron
113            | TexTokenType::Pi
114            | TexTokenType::Rho
115            | TexTokenType::Sigma
116            | TexTokenType::Tau
117            | TexTokenType::Upsilon
118            | TexTokenType::Phi
119            | TexTokenType::Chi
120            | TexTokenType::Psi
121            | TexTokenType::Omega
122            | TexTokenType::VarEpsilon
123            | TexTokenType::VarTheta
124            | TexTokenType::VarKappa
125            | TexTokenType::VarPi
126            | TexTokenType::VarRho
127            | TexTokenType::VarSigma
128            | TexTokenType::VarPhi
129            | TexTokenType::UpperGamma
130            | TexTokenType::UpperDelta
131            | TexTokenType::UpperTheta
132            | TexTokenType::UpperLambda
133            | TexTokenType::UpperXi
134            | TexTokenType::UpperPi
135            | TexTokenType::UpperSigma
136            | TexTokenType::UpperUpsilon
137            | TexTokenType::UpperPhi
138            | TexTokenType::UpperPsi
139            | TexTokenType::UpperOmega => {
140                if let Some(node) = tree.as_node() {
141                    Ok(Some(TexItem::Command(self.build_command(node, source)?)))
142                }
143                else {
144                    let name = match kind {
145                        TexTokenType::Sum => "sum".to_string(),
146                        TexTokenType::Int => "int".to_string(),
147                        TexTokenType::Lim => "lim".to_string(),
148                        TexTokenType::Frac => "frac".to_string(),
149                        TexTokenType::Sqrt => "sqrt".to_string(),
150                        TexTokenType::Alpha => "alpha".to_string(),
151                        TexTokenType::Beta => "beta".to_string(),
152                        TexTokenType::Gamma => "gamma".to_string(),
153                        TexTokenType::Delta => "delta".to_string(),
154                        TexTokenType::Epsilon => "epsilon".to_string(),
155                        TexTokenType::Zeta => "zeta".to_string(),
156                        TexTokenType::Eta => "eta".to_string(),
157                        TexTokenType::Theta => "theta".to_string(),
158                        TexTokenType::Iota => "iota".to_string(),
159                        TexTokenType::Kappa => "kappa".to_string(),
160                        TexTokenType::Lambda => "lambda".to_string(),
161                        TexTokenType::Mu => "mu".to_string(),
162                        TexTokenType::Nu => "nu".to_string(),
163                        TexTokenType::Xi => "xi".to_string(),
164                        TexTokenType::Omicron => "omicron".to_string(),
165                        TexTokenType::Pi => "pi".to_string(),
166                        TexTokenType::Rho => "rho".to_string(),
167                        TexTokenType::Sigma => "sigma".to_string(),
168                        TexTokenType::Tau => "tau".to_string(),
169                        TexTokenType::Upsilon => "upsilon".to_string(),
170                        TexTokenType::Phi => "phi".to_string(),
171                        TexTokenType::Chi => "chi".to_string(),
172                        TexTokenType::Psi => "psi".to_string(),
173                        TexTokenType::Omega => "omega".to_string(),
174                        TexTokenType::VarEpsilon => "varepsilon".to_string(),
175                        TexTokenType::VarTheta => "vartheta".to_string(),
176                        TexTokenType::VarKappa => "varkappa".to_string(),
177                        TexTokenType::VarPi => "varpi".to_string(),
178                        TexTokenType::VarRho => "varrho".to_string(),
179                        TexTokenType::VarSigma => "varsigma".to_string(),
180                        TexTokenType::VarPhi => "varphi".to_string(),
181                        TexTokenType::UpperGamma => "Gamma".to_string(),
182                        TexTokenType::UpperDelta => "Delta".to_string(),
183                        TexTokenType::UpperTheta => "Theta".to_string(),
184                        TexTokenType::UpperLambda => "Lambda".to_string(),
185                        TexTokenType::UpperXi => "Xi".to_string(),
186                        TexTokenType::UpperPi => "Pi".to_string(),
187                        TexTokenType::UpperSigma => "Sigma".to_string(),
188                        TexTokenType::UpperUpsilon => "Upsilon".to_string(),
189                        TexTokenType::UpperPhi => "Phi".to_string(),
190                        TexTokenType::UpperPsi => "Psi".to_string(),
191                        TexTokenType::UpperOmega => "Omega".to_string(),
192                        _ => tree.text(source).trim_start_matches('\\').to_string(),
193                    };
194                    Ok(Some(TexItem::Command(TexCommand { span: tree.span().into(), name, arguments: Vec::new() })))
195                }
196            }
197            TexTokenType::Environment => Ok(Some(TexItem::Environment(self.build_environment(tree.as_node().unwrap(), source)?))),
198            TexTokenType::Group => Ok(Some(TexItem::Group(self.build_group(tree.as_node().unwrap(), source)?))),
199            TexTokenType::InlineMath | TexTokenType::DisplayMath => Ok(Some(TexItem::Math(self.build_math(tree.as_node().unwrap(), source)?))),
200            TexTokenType::Superscript => Ok(Some(TexItem::Superscript(self.build_superscript(tree.as_node().unwrap(), source)?))),
201            TexTokenType::Subscript => Ok(Some(TexItem::Subscript(self.build_subscript(tree.as_node().unwrap(), source)?))),
202            TexTokenType::Identifier | TexTokenType::Number | TexTokenType::Text => Ok(Some(TexItem::Text { span: tree.span().into(), content: tree.text(source).to_string() })),
203            TexTokenType::Comment => Ok(Some(TexItem::Comment { span: tree.span().into(), content: tree.text(source).to_string() })),
204            _ => {
205                if tree.as_token().is_some() {
206                    Ok(Some(TexItem::Text { span: tree.span().into(), content: tree.text(source).to_string() }))
207                }
208                else {
209                    Ok(None)
210                }
211            }
212        }
213    }
214
215    fn build_superscript<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexSuperscript, OakError> {
216        let mut content = TexRoot::new(node.span().into());
217        for child in node.children() {
218            let kind: TexTokenType = child.kind();
219            if kind == TexTokenType::Caret {
220                continue;
221            }
222            if let Some(item) = self.build_item(child, source)? {
223                content.items.push(item)
224            }
225        }
226        Ok(TexSuperscript {
227            span: node.span().into(),
228            target: None, // Will be filled later by a post-processor if needed
229            content: Box::new(content),
230        })
231    }
232
233    fn build_subscript<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexSubscript, OakError> {
234        let mut content = TexRoot::new(node.span().into());
235        for child in node.children() {
236            let kind: TexTokenType = child.kind();
237            if kind == TexTokenType::Underscore {
238                continue;
239            }
240            if let Some(item) = self.build_item(child, source)? {
241                content.items.push(item)
242            }
243        }
244        Ok(TexSubscript {
245            span: node.span().into(),
246            target: None, // Will be filled later by a post-processor if needed
247            content: Box::new(content),
248        })
249    }
250
251    fn build_command<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexCommand, OakError> {
252        let mut name = String::new();
253        let mut arguments = Vec::new();
254
255        for child in node.children() {
256            let kind: TexTokenType = child.kind();
257            match kind {
258                TexTokenType::Backslash
259                | TexTokenType::Command
260                | TexTokenType::BeginKeyword
261                | TexTokenType::EndKeyword
262                | TexTokenType::Frac
263                | TexTokenType::Sqrt
264                | TexTokenType::Sum
265                | TexTokenType::Int
266                | TexTokenType::Lim
267                | TexTokenType::SectionKeyword
268                | TexTokenType::SubsectionKeyword
269                | TexTokenType::SubsubsectionKeyword
270                | TexTokenType::ChapterKeyword
271                | TexTokenType::PartKeyword
272                | TexTokenType::TitleKeyword
273                | TexTokenType::AuthorKeyword
274                | TexTokenType::DateKeyword
275                | TexTokenType::MaketitleKeyword
276                | TexTokenType::TableofcontentsKeyword
277                | TexTokenType::ItemKeyword
278                | TexTokenType::LabelKeyword
279                | TexTokenType::RefKeyword
280                | TexTokenType::CiteKeyword
281                | TexTokenType::IncludegraphicsKeyword
282                | TexTokenType::TextbfKeyword
283                | TexTokenType::TextitKeyword
284                | TexTokenType::EmphKeyword
285                | TexTokenType::Alpha
286                | TexTokenType::Beta
287                | TexTokenType::Gamma
288                | TexTokenType::Delta
289                | TexTokenType::Epsilon
290                | TexTokenType::Zeta
291                | TexTokenType::Eta
292                | TexTokenType::Theta
293                | TexTokenType::Iota
294                | TexTokenType::Kappa
295                | TexTokenType::Lambda
296                | TexTokenType::Mu
297                | TexTokenType::Nu
298                | TexTokenType::Xi
299                | TexTokenType::Omicron
300                | TexTokenType::Pi
301                | TexTokenType::Rho
302                | TexTokenType::Sigma
303                | TexTokenType::Tau
304                | TexTokenType::Upsilon
305                | TexTokenType::Phi
306                | TexTokenType::Chi
307                | TexTokenType::Psi
308                | TexTokenType::Omega
309                | TexTokenType::VarEpsilon
310                | TexTokenType::VarTheta
311                | TexTokenType::VarKappa
312                | TexTokenType::VarPi
313                | TexTokenType::VarRho
314                | TexTokenType::VarSigma
315                | TexTokenType::VarPhi
316                | TexTokenType::UpperGamma
317                | TexTokenType::UpperDelta
318                | TexTokenType::UpperTheta
319                | TexTokenType::UpperLambda
320                | TexTokenType::UpperXi
321                | TexTokenType::UpperPi
322                | TexTokenType::UpperSigma
323                | TexTokenType::UpperUpsilon
324                | TexTokenType::UpperPhi
325                | TexTokenType::UpperPsi
326                | TexTokenType::UpperOmega
327                | TexTokenType::TextBf
328                | TexTokenType::TextIt
329                | TexTokenType::TextSc
330                | TexTokenType::TextTt
331                | TexTokenType::Emph
332                | TexTokenType::Underline => {
333                    let text = child.text(source);
334                    if text.starts_with('\\') { name = text[1..].to_string() } else { name = text.to_string() }
335                }
336                TexTokenType::OptionalArgument => arguments.push(TexArgument::Optional(self.build_content(child.as_node().unwrap(), source)?)),
337                TexTokenType::MandatoryArgument => arguments.push(TexArgument::Required(self.build_content(child.as_node().unwrap(), source)?)),
338                _ => {}
339            }
340        }
341
342        Ok(TexCommand { span: node.span().into(), name, arguments })
343    }
344
345    fn build_group<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexGroup, OakError> {
346        Ok(TexGroup { span: node.span().into(), content: self.build_content(node, source)? })
347    }
348
349    fn build_math<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexMath, OakError> {
350        let kind: TexTokenType = node.kind();
351        Ok(TexMath { span: node.span().into(), content: self.build_content(node, source)?, is_display: kind == TexTokenType::DoubleDollar })
352    }
353
354    fn build_environment<S: Source + ?Sized>(&self, node: RedNode<TexLanguage>, source: &S) -> Result<TexEnvironment, OakError> {
355        let mut name = String::new();
356        let mut arguments = Vec::new();
357        let mut content = TexRoot::new(node.span().into());
358
359        for child in node.children() {
360            let kind: TexTokenType = child.kind();
361            match kind {
362                TexTokenType::BeginEnvironment => {
363                    for sub_child in child.as_node().unwrap().children() {
364                        let sub_kind: TexTokenType = sub_child.kind();
365                        match sub_kind {
366                            TexTokenType::MandatoryArgument => {
367                                // The first mandatory argument is the environment name
368                                if name.is_empty() {
369                                    let arg_root = self.build_content(sub_child.as_node().unwrap(), source)?;
370                                    for item in arg_root.items {
371                                        if let TexItem::Text { content, .. } = item {
372                                            name.push_str(&content)
373                                        }
374                                    }
375                                }
376                                else {
377                                    arguments.push(TexArgument::Required(self.build_content(sub_child.as_node().unwrap(), source)?))
378                                }
379                            }
380                            TexTokenType::OptionalArgument => arguments.push(TexArgument::Optional(self.build_content(sub_child.as_node().unwrap(), source)?)),
381                            _ => {}
382                        }
383                    }
384                }
385                TexTokenType::EndEnvironment => {}
386                _ => {
387                    if let Some(item) = self.build_item(child, source)? {
388                        content.items.push(item)
389                    }
390                }
391            }
392        }
393
394        Ok(TexEnvironment { span: node.span().into(), name, arguments, content })
395    }
396}
397
398fn is_delimiter(kind: TexTokenType) -> bool {
399    matches!(kind, TexTokenType::LeftBrace | TexTokenType::RightBrace | TexTokenType::LeftBracket | TexTokenType::RightBracket | TexTokenType::Dollar | TexTokenType::DoubleDollar)
400}
oak_tex/builder/mod.rs

oak_tex/builder/
mod.rs
