conjure_cp_essence_parser/parser/
domain.rs

1use super::atom::parse_int;
2use super::util::named_children;
3use crate::diagnostics::diagnostics_api::SymbolKind;
4use crate::diagnostics::source_map::{HoverInfo, span_with_hover};
5use crate::errors::FatalParseError;
6use crate::expression::parse_expression;
7use crate::parser::ParseContext;
8use crate::{RecoverableParseError, child};
9use conjure_cp_core::ast::{
10    DeclarationPtr, Domain, DomainPtr, Field, IntVal, Moo, Name, Range, Reference, SetAttr,
11};
12use tree_sitter::Node;
13
14use crate::field;
15
16/// Parse an Essence variable domain into its Conjure AST representation.
17pub fn parse_domain(
18    ctx: &mut ParseContext,
19    domain: Node,
20) -> Result<Option<DomainPtr>, FatalParseError> {
21    match domain.kind() {
22        "domain" => {
23            let inner = match domain.child(0) {
24                Some(node) => node,
25                None => {
26                    ctx.record_error(RecoverableParseError::new(
27                        format!("{} in expression of kind '{}'", "domain", domain.kind()),
28                        Some(domain.range()),
29                    ));
30                    return Ok(None);
31                }
32            };
33            parse_domain(ctx, inner)
34        }
35        "bool_domain" => {
36            ctx.add_span_and_doc_hover(&domain, "L_bool", SymbolKind::Domain, None, None);
37            Ok(Some(Domain::bool()))
38        }
39        "int_domain" => parse_int_domain(ctx, domain),
40        "identifier" => {
41            let Some(decl) = get_declaration_ptr_from_identifier(ctx, domain)? else {
42                return Ok(None);
43            };
44            let Some(dom) = Domain::reference(decl) else {
45                ctx.record_error(crate::errors::RecoverableParseError::new(
46                    format!(
47                        "The identifier '{}' is not a valid domain",
48                        &ctx.source_code[domain.start_byte()..domain.end_byte()]
49                    ),
50                    Some(domain.range()),
51                ));
52                return Ok(None);
53            };
54            let name = &ctx.source_code[domain.start_byte()..domain.end_byte()];
55
56            // Not form docs, because we need context specific hover info
57            span_with_hover(
58                &domain,
59                ctx.source_code,
60                ctx.source_map,
61                HoverInfo {
62                    description: format!("Domain reference: {name}"),
63                    doc_key: None,
64                    kind: Some(SymbolKind::Variable),
65                    ty: None,
66                    decl_span: None, // could link to the declaration span if we wanted
67                },
68            );
69            Ok(Some(dom))
70        }
71        "tuple_domain" => parse_tuple_domain(ctx, domain),
72        "matrix_domain" => parse_matrix_domain(ctx, domain),
73        "record_domain" => parse_record_domain(ctx, domain),
74        "set_domain" => parse_set_domain(ctx, domain),
75        _ => {
76            ctx.record_error(RecoverableParseError::new(
77                format!("{} is not a supported domain type", domain.kind()),
78                Some(domain.range()),
79            ));
80            Ok(None)
81        }
82    }
83}
84
85fn get_declaration_ptr_from_identifier(
86    ctx: &mut ParseContext,
87    identifier: Node,
88) -> Result<Option<DeclarationPtr>, FatalParseError> {
89    let name = Name::user(&ctx.source_code[identifier.start_byte()..identifier.end_byte()]);
90    let decl = ctx.symbols.as_ref().unwrap().read().lookup(&name);
91
92    if decl.is_none() {
93        ctx.record_error(crate::errors::RecoverableParseError::new(
94            format!("The identifier '{}' is not defined", name),
95            Some(identifier.range()),
96        ));
97        return Ok(None);
98    }
99    match decl {
100        Some(decl) => Ok(Some(decl)),
101        None => {
102            ctx.record_error(crate::errors::RecoverableParseError::new(
103                format!("The identifier '{}' is not defined", name),
104                Some(identifier.range()),
105            ));
106            Ok(None)
107        }
108    }
109}
110
111/// Parse an integer domain. Can be a single integer or a range.
112fn parse_int_domain(
113    ctx: &mut ParseContext,
114    int_domain: Node,
115) -> Result<Option<DomainPtr>, FatalParseError> {
116    let int_keyword_node = child!(int_domain, 0, "int");
117    if int_domain.child_count() == 1 {
118        // for domains of just 'int' with no range
119        ctx.add_span_and_doc_hover(&int_keyword_node, "L_int", SymbolKind::Domain, None, None);
120        return Ok(Some(Domain::int(vec![Range::Bounded(i32::MIN, i32::MAX)])));
121    }
122
123    let Some(range_list) = field!(recover, ctx, int_domain, "ranges") else {
124        return Ok(None);
125    };
126    let mut ranges_unresolved: Vec<Range<IntVal>> = Vec::new();
127    let mut all_resolved = true;
128
129    for domain_component in named_children(&range_list) {
130        match domain_component.kind() {
131            "atom" | "arithmetic_expr" => {
132                let Some(int_val) = parse_int_val(ctx, domain_component)? else {
133                    return Ok(None);
134                };
135
136                if !matches!(int_val, IntVal::Const(_)) {
137                    all_resolved = false;
138                }
139                ranges_unresolved.push(Range::Single(int_val));
140            }
141            "int_range" => {
142                let lower_bound = match domain_component.child_by_field_name("lower") {
143                    Some(node) => {
144                        match parse_int_val(ctx, node)? {
145                            Some(val) => Some(val),
146                            None => return Ok(None), // semantic error occurred
147                        }
148                    }
149                    None => None,
150                };
151                let upper_bound = match domain_component.child_by_field_name("upper") {
152                    Some(node) => {
153                        match parse_int_val(ctx, node)? {
154                            Some(val) => Some(val),
155                            None => return Ok(None), // semantic error occurred
156                        }
157                    }
158                    None => None,
159                };
160
161                match (lower_bound, upper_bound) {
162                    (Some(lower), Some(upper)) => {
163                        // Check if both bounds are constants and validate lower <= upper
164                        if let (IntVal::Const(l), IntVal::Const(u)) = (&lower, &upper) {
165                            if l > u {
166                                ctx.record_error(crate::errors::RecoverableParseError::new(
167                                    format!(
168                                        "Invalid integer range: lower bound {} is greater than upper bound {}",
169                                        l, u
170                                    ),
171                                    Some(domain_component.range()),
172                                ));
173                            }
174                        } else {
175                            all_resolved = false;
176                        }
177                        ranges_unresolved.push(Range::Bounded(lower, upper));
178                    }
179                    (Some(lower), None) => {
180                        if !matches!(lower, IntVal::Const(_)) {
181                            all_resolved = false;
182                        }
183                        ranges_unresolved.push(Range::UnboundedR(lower));
184                    }
185                    (None, Some(upper)) => {
186                        if !matches!(upper, IntVal::Const(_)) {
187                            all_resolved = false;
188                        }
189                        ranges_unresolved.push(Range::UnboundedL(upper));
190                    }
191                    _ => {
192                        ctx.record_error(RecoverableParseError::new(
193                            "Invalid int range: must have at least a lower or upper bound"
194                                .to_string(),
195                            Some(domain_component.range()),
196                        ));
197                        return Ok(None);
198                    }
199                }
200            }
201            _ => {
202                ctx.record_error(RecoverableParseError::new(
203                    format!(
204                        "Unexpected int domain component: {}",
205                        domain_component.kind()
206                    ),
207                    Some(domain_component.range()),
208                ));
209                return Ok(None);
210            }
211        }
212    }
213
214    // If all values are resolved constants, convert IntVals to raw integers
215    if all_resolved {
216        let ranges: Vec<Range<i32>> = ranges_unresolved
217            .into_iter()
218            .map(|r| r.resolve())
219            .collect::<Result<_, _>>()
220            .map_err(|e| {
221                FatalParseError::internal_error(
222                    format!("could not resolve range: {e}"),
223                    Some(int_domain.range()),
224                )
225            })?;
226
227        ctx.add_span_and_doc_hover(&int_keyword_node, "L_int", SymbolKind::Domain, None, None);
228        Ok(Some(Domain::int(ranges)))
229    } else {
230        // Otherwise, keep as an expression-based domain
231
232        // Adding int keyword to the source map with hover info from documentation
233        ctx.add_span_and_doc_hover(&int_keyword_node, "L_int", SymbolKind::Domain, None, None);
234        Ok(Some(Domain::int(ranges_unresolved)))
235    }
236}
237
238// Helper function to parse a node into an IntVal
239// Handles constants, references, and arbitrary expressions
240fn parse_int_val(ctx: &mut ParseContext, node: Node) -> Result<Option<IntVal>, FatalParseError> {
241    // For atoms, try to parse as a constant integer first
242    if node.kind() == "atom" {
243        let text = &ctx.source_code[node.start_byte()..node.end_byte()];
244        if let Ok(integer) = text.parse::<i32>() {
245            return Ok(Some(IntVal::new_const(integer)));
246        }
247        // Otherwise, check if it's an identifier reference
248        let Some(decl) = get_declaration_ptr_from_identifier(ctx, node)? else {
249            // If identifier isn't defined, it's a semantic error
250            return Ok(None);
251        };
252        return Ok(Some(IntVal::Reference(Reference::new(decl))));
253    }
254
255    // For anything else, parse as an expression
256    let Some(expr) = parse_expression(ctx, node)? else {
257        return Ok(None);
258    };
259    Ok(Some(IntVal::Expr(Moo::new(expr))))
260}
261
262fn parse_tuple_domain(
263    ctx: &mut ParseContext,
264    tuple_domain: Node,
265) -> Result<Option<DomainPtr>, FatalParseError> {
266    let mut domains: Vec<DomainPtr> = Vec::new();
267    for domain in named_children(&tuple_domain) {
268        let Some(parsed_domain) = parse_domain(ctx, domain)? else {
269            return Ok(None);
270        };
271        domains.push(parsed_domain);
272    }
273
274    // extract the first child node which should be the 'tuple' keyword for hover info
275    if let Some(first) = tuple_domain.child(0)
276        && first.kind() == "tuple"
277    {
278        // Adding tuple to the source map with hover info from documentation
279        ctx.add_span_and_doc_hover(&first, "L_tuple", SymbolKind::Domain, None, None);
280    }
281
282    Ok(Some(Domain::tuple(domains)))
283}
284
285fn parse_matrix_domain(
286    ctx: &mut ParseContext,
287    matrix_domain: Node,
288) -> Result<Option<DomainPtr>, FatalParseError> {
289    let mut domains: Vec<DomainPtr> = Vec::new();
290    let Some(index_domain_list) = field!(recover, ctx, matrix_domain, "index_domain_list") else {
291        return Ok(None);
292    };
293    for domain in named_children(&index_domain_list) {
294        let Some(parsed_domain) = parse_domain(ctx, domain)? else {
295            return Ok(None);
296        };
297        domains.push(parsed_domain);
298    }
299    let Some(value_domain_node) = field!(recover, ctx, matrix_domain, "value_domain") else {
300        return Ok(None);
301    };
302    let Some(value_domain) = parse_domain(ctx, value_domain_node)? else {
303        return Ok(None);
304    };
305
306    // Adding matrix to the source map with hover info from documentation
307    let matrix_keyword_node = child!(matrix_domain, 0, "matrix");
308    ctx.add_span_and_doc_hover(
309        &matrix_keyword_node,
310        "matrix",
311        SymbolKind::Domain,
312        None,
313        None,
314    );
315    Ok(Some(Domain::matrix(value_domain, domains)))
316}
317
318fn parse_record_domain(
319    ctx: &mut ParseContext,
320    record_domain: Node,
321) -> Result<Option<DomainPtr>, FatalParseError> {
322    let mut record_entries: Vec<Field<DomainPtr>> = Vec::new();
323    for record_entry in named_children(&record_domain) {
324        let Some(name_node) = field!(recover, ctx, record_entry, "name") else {
325            return Ok(None);
326        };
327        let name = Name::user(&ctx.source_code[name_node.start_byte()..name_node.end_byte()]);
328        let Some(domain_node) = field!(recover, ctx, record_entry, "domain") else {
329            return Ok(None);
330        };
331        let Some(value) = parse_domain(ctx, domain_node)? else {
332            return Ok(None);
333        };
334        record_entries.push(Field { name, value });
335    }
336
337    // Adding record keyword to the source map with hover info from documentation
338    let record_keyword_node = child!(record_domain, 0, "record");
339    ctx.add_span_and_doc_hover(
340        &record_keyword_node,
341        "L_record",
342        SymbolKind::Domain,
343        None,
344        None,
345    );
346    Ok(Some(Domain::record(record_entries)))
347}
348
349pub fn parse_set_domain(
350    ctx: &mut ParseContext,
351    set_domain: Node,
352) -> Result<Option<DomainPtr>, FatalParseError> {
353    let mut set_attribute: Option<SetAttr> = None;
354    let mut value_domain: Option<DomainPtr> = None;
355
356    for child in named_children(&set_domain) {
357        match child.kind() {
358            "set_attributes" => {
359                // Check if we have both minSize and maxSize (minMax case)
360                let min_value_node = child.child_by_field_name("min_value");
361                let max_value_node = child.child_by_field_name("max_value");
362                let size_value_node = child.child_by_field_name("size_value");
363
364                if let (Some(min_node), Some(max_node)) = (min_value_node, max_value_node) {
365                    // MinMax case
366                    let Some(min_val) = parse_int(ctx, &min_node) else {
367                        return Ok(None);
368                    };
369                    let Some(max_val) = parse_int(ctx, &max_node) else {
370                        return Ok(None);
371                    };
372
373                    set_attribute = Some(SetAttr::new_min_max_size(min_val, max_val));
374                } else if let Some(size_node) = size_value_node {
375                    // Size case
376                    let Some(size_val) = parse_int(ctx, &size_node) else {
377                        return Ok(None);
378                    };
379                    set_attribute = Some(SetAttr::new_size(size_val));
380                } else if let Some(min_node) = min_value_node {
381                    // MinSize only case
382                    let Some(min_val) = parse_int(ctx, &min_node) else {
383                        return Ok(None);
384                    };
385                    set_attribute = Some(SetAttr::new_min_size(min_val));
386                } else if let Some(max_node) = max_value_node {
387                    // MaxSize only case
388                    let Some(max_val) = parse_int(ctx, &max_node) else {
389                        return Ok(None);
390                    };
391                    set_attribute = Some(SetAttr::new_max_size(max_val));
392                }
393            }
394            "domain" => {
395                let Some(parsed_domain) = parse_domain(ctx, child)? else {
396                    return Ok(None);
397                };
398                value_domain = Some(parsed_domain);
399            }
400            _ => {
401                ctx.record_error(RecoverableParseError::new(
402                    format!("Unrecognized set domain child kind: {}", child.kind()),
403                    Some(child.range()),
404                ));
405                return Ok(None);
406            }
407        }
408    }
409
410    if let Some(domain) = value_domain {
411        // Adding set to the source map with hover info from documentation
412        let set_keyword_node = child!(set_domain, 0, "set");
413        // No documentation available for set domain, using fallback description
414        ctx.add_span_and_doc_hover(&set_keyword_node, "set", SymbolKind::Domain, None, None);
415        Ok(Some(Domain::set(set_attribute.unwrap_or_default(), domain)))
416    } else {
417        ctx.record_error(RecoverableParseError::new(
418            "Set domain must have a value domain".to_string(),
419            Some(set_domain.range()),
420        ));
421        Ok(None)
422    }
423}
conjure_cp_essence_parser/parser/domain.rs

conjure_cp_essence_parser/parser/
domain.rs
