Lines
93.07 %
Functions
58.62 %
pub use conjure_cp_core::error::Error as ConjureParseError;
use conjure_cp_core::error::Error;
use serde_json::Error as JsonError;
use thiserror::Error as ThisError;
#[derive(Debug, ThisError)]
pub enum FatalParseError {
#[error("Failed to read Essence file `{path}`: {source}")]
FileRead {
path: String,
#[source]
source: std::io::Error,
},
#[error("Could not parse Essence AST: {0}")]
TreeSitterError(String),
#[error("Error running `conjure pretty`: {0}")]
ConjurePrettyError(String),
#[error("Internal parser error: {msg}{}\nThis indicates a bug in the parser or syntax validator. Please report this issue.",
match range {
Some(range) => format!(" at {}-{}", range.start_point, range.end_point),
None => "".to_string(),
}
)]
InternalError {
msg: String,
range: Option<tree_sitter::Range>,
#[error("JSON Error: {0}")]
JsonError(#[from] JsonError),
#[error("Error: {0} is not yet implemented.")]
NotImplemented(String),
#[error("Error: {0}")]
Other(Error),
impl FatalParseError {
pub fn internal_error(msg: String, range: Option<tree_sitter::Range>) -> Self {
FatalParseError::InternalError { msg, range }
impl From<ConjureParseError> for FatalParseError {
fn from(value: ConjureParseError) -> Self {
match value {
Error::Parse(msg) => FatalParseError::internal_error(msg, None),
Error::NotImplemented(msg) => FatalParseError::NotImplemented(msg),
Error::Json(err) => FatalParseError::JsonError(err),
Error::Other(err) => FatalParseError::Other(err.into()),
#[derive(Debug, Clone)]
pub struct RecoverableParseError {
pub msg: String,
pub range: Option<tree_sitter::Range>,
pub file_name: Option<String>,
pub source_code: Option<String>,
impl RecoverableParseError {
pub fn new(msg: String, range: Option<tree_sitter::Range>) -> Self {
Self {
msg,
range,
file_name: None,
source_code: None,
pub fn enrich(mut self, file_name: Option<String>, source_code: Option<String>) -> Self {
self.file_name = file_name;
self.source_code = source_code;
self
impl std::fmt::Display for RecoverableParseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
// If we have all the info, format nicely with source context
if let (Some(range), Some(file_name), Some(source_code)) =
(&self.range, &self.file_name, &self.source_code)
{
let line_num = range.start_point.row + 1; // tree-sitter uses 0-indexed rows
let col_num = range.start_point.column + 1; // tree-sitter uses 0-indexed columns
// Get the specific line from source code
let lines: Vec<&str> = source_code.lines().collect();
let line_content = lines.get(range.start_point.row).unwrap_or(&"");
// Build the pointer line (spaces + ^)
let pointer = " ".repeat(range.start_point.column) + "^";
write!(
f,
"{}:{}:{}:\n |\n{} | {}\n | {}\n{}",
file_name, line_num, col_num, line_num, line_content, pointer, self.msg
)
} else {
// Fall back to simple format without context
write!(f, "Essence syntax error: {}", self.msg)?;
if let Some(range) = &self.range {
write!(f, " at {}-{}", range.start_point, range.end_point)?;
Ok(())
/// Error type for issues during model instantiation (when applying parameters to a problem model).
#[derive(Debug)]
pub struct InstantiateModelError {
impl std::fmt::Display for InstantiateModelError {
write!(f, "{}", self.msg)
impl std::error::Error for InstantiateModelError {}
/// Collection of parse errors
pub enum ParseErrorCollection {
/// A single fatal error that stops parsing entirely
Fatal(FatalParseError),
/// Multiple recoverable errors accumulated during parsing
Multiple {
errors: Vec<RecoverableParseError>,
InstantiateModel(InstantiateModelError),
impl ParseErrorCollection {
/// Create a fatal error collection from a single fatal error
pub fn fatal(error: FatalParseError) -> Self {
ParseErrorCollection::Fatal(error)
/// Create a multiple error collection from recoverable errors
/// This enriches all errors with file_name and source_code
pub fn multiple(
source_code: Option<String>,
file_name: Option<String>,
) -> Self {
let enriched_errors = errors
.into_iter()
.map(|err| err.enrich(file_name.clone(), source_code.clone()))
.collect();
ParseErrorCollection::Multiple {
errors: enriched_errors,
impl std::fmt::Display for ParseErrorCollection {
match self {
ParseErrorCollection::Fatal(error) => write!(f, "{}", error),
ParseErrorCollection::InstantiateModel(error) => write!(f, "{}", error),
ParseErrorCollection::Multiple { errors } => {
// Create indices sorted by line and column
let mut indices: Vec<usize> = (0..errors.len()).collect();
indices.sort_by(|&a, &b| {
match (&errors[a], &errors[b]) {
(
RecoverableParseError {
range: Some(r1), ..
range: Some(r2), ..
) => {
// Compare by row first, then by column
match r1.start_point.row.cmp(&r2.start_point.row) {
std::cmp::Ordering::Equal => {
r1.start_point.column.cmp(&r2.start_point.column)
other => other,
// Errors without ranges go last
(RecoverableParseError { range: Some(_), .. }, _) => {
std::cmp::Ordering::Less
(_, RecoverableParseError { range: Some(_), .. }) => {
std::cmp::Ordering::Greater
_ => std::cmp::Ordering::Equal,
});
// Print out each error using Display
for (i, &idx) in indices.iter().enumerate() {
if i > 0 {
write!(f, "\n\n")?;
write!(f, "{}", errors[idx])?;
impl std::error::Error for ParseErrorCollection {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn instantiate_model_error_display_and_error_trait() {
let err = InstantiateModelError {
msg: "hello".to_string(),
};
assert_eq!(err.to_string(), "hello");
let _as_error: &dyn std::error::Error = &err;
fn parse_error_collection_instantiate_model_variant_is_displayed() {
let err = ParseErrorCollection::InstantiateModel(InstantiateModelError {
msg: "missing param".to_string(),
assert_eq!(err.to_string(), "missing param");
fn parse_error_collection_multiple_constructor_works() {
let err = ParseErrorCollection::multiple(
vec![RecoverableParseError::new("bad token".to_string(), None)],
None,
);
let formatted = err.to_string();
assert!(formatted.contains("bad token"));