Lines
62.07 %
Functions
10.67 %
use crate::errors::{FatalParseError, RecoverableParseError};
use crate::expression::parse_expression;
use crate::field;
use crate::parser::domain::parse_domain;
use crate::util::named_children;
use conjure_cp_core::ast::{AbstractLiteral, DomainPtr, Expression, SymbolTablePtr};
use conjure_cp_core::{domain_int, range};
use tree_sitter::Node;
pub fn parse_abstract(
node: &Node,
source_code: &str,
symbols_ptr: Option<SymbolTablePtr>,
errors: &mut Vec<RecoverableParseError>,
) -> Result<AbstractLiteral<Expression>, FatalParseError> {
match node.kind() {
"record" => parse_record(node, source_code, symbols_ptr, errors),
"tuple" => parse_tuple(node, source_code, symbols_ptr, errors),
"matrix" => parse_matrix(node, source_code, symbols_ptr, errors),
"set_literal" => parse_set_literal(node, source_code, symbols_ptr, errors),
_ => Err(FatalParseError::syntax_error(
format!("Expected abstract literal, got: {}", node.kind()),
Some(node.range()),
)),
}
fn parse_record(
let mut values = Vec::new();
for child in node.children_by_field_name("name_value_pair", &mut node.walk()) {
let name_node = field!(child, "name");
let name_str = &source_code[name_node.start_byte()..name_node.end_byte()];
let name = conjure_cp_core::ast::Name::user(name_str);
let value: Expression = parse_expression(
field!(child, "value"),
source_code,
node,
symbols_ptr.clone(),
errors,
)?;
values.push(conjure_cp_core::ast::records::RecordValue { name, value });
Ok(AbstractLiteral::Record(values))
fn parse_tuple(
let mut elements = Vec::new();
for child in named_children(node) {
elements.push(parse_expression(
child,
)?);
Ok(AbstractLiteral::Tuple(elements))
fn parse_matrix(
let mut elements = vec![];
let mut domain: Option<DomainPtr> = None;
if child.kind() == "arithmetic_expr"
|| child.kind() == "bool_expr"
|| child.kind() == "comparison_expr"
|| child.kind() == "atom"
{
} else {
domain = Some(parse_domain(
if domain.is_none() {
let count = elements.len() as i32;
domain = Some(domain_int!(1..count));
Ok(AbstractLiteral::Matrix(elements, domain.unwrap()))
fn parse_set_literal(
Ok(AbstractLiteral::Set(elements))