1 
#![allow(clippy::legacy_numeric_constants)]
2 

            

        

            

                3
            

            

                
            

            

                
use std::cell::RefCell;

            

        

            

                4
            

            

                
            

            

                
use std::collections::BTreeMap;

            

        

            

                5
            

            

                
            

            

                
use std::rc::Rc;

            

        

            

                6
            

            

                
            

            

                
use tree_sitter::Node;

            

        

            

                7
            

            

                
            

            

                

            

        

            

                8
            

            

                
            

            

                
use super::domain::parse_domain;

            

        

            

                9
            

            

                
            

            

                
use super::util::named_children;

            

        

            

                10
            

            

                
            

            

                
use crate::EssenceParseError;

            

        

            

                11
            

            

                
            

            

                
use conjure_cp_core::ast::{DomainPtr, Name, SymbolTable};

            

        

            

                12
            

            

                
            

            

                

            

        

            

                13
            

            

                
            

            

                
/// Parse a find statement into a map of decision variable names to their domains.

            

        

            

                14
            

            

                
            

            

                
pub fn parse_find_statement(

            

        

            

                15
            

            

                
            

            

                
    find_statement: Node,

            

        

            

                16
            

            

                
            

            

                
    source_code: &str,

            

        

            

                17
            

            

                
            

            

                
    symbols: Option<Rc<RefCell<SymbolTable>>>,

            

        

            

                18
            

            

                
            

            

                
) -> Result<BTreeMap<Name, DomainPtr>, EssenceParseError> {

            

        

            

                19
            

            

                
            

            

                
    let mut vars = BTreeMap::new();

            

        

            

                20
            

            

                
            

            

                

            

        

            

                21
            

            

                
            

            

                
    let domain = find_statement

            

        

            

                22
            

            

                
            

            

                
        .child_by_field_name("domain")

            

        

            

                23
            

            

                
            

            

                
        .expect("No domain found in find statement");

            

        

            

                24
            

            

                
            

            

                
    let domain = parse_domain(domain, source_code, symbols)?;

            

        

            

                25
            

            

                
            

            

                

            

        

            

                26
            

            

                
            

            

                
    let variable_list = find_statement

            

        

            

                27
            

            

                
            

            

                
        .child_by_field_name("variables")

            

        

            

                28
            

            

                
            

            

                
        .expect("No variable list found");

            

        

            

                29
            

            

                
            

            

                
    for variable in named_children(&variable_list) {

            

        

            

                30
            

            

                
            

            

                
        let variable_name = &source_code[variable.start_byte()..variable.end_byte()];

            

        

            

                31
            

            

                
            

            

                
        vars.insert(Name::user(variable_name), domain.clone());

            

        

            

                32
            

            

                
            

            

                
    }

            

        

            

                33
            

            

                
            

            

                

            

        

            

                34
            

            

                
            

            

                
    Ok(vars)

            

        

            

                35
            

            

                
            

            

                
}