93 lines
2.5 KiB
Rust
93 lines
2.5 KiB
Rust
use std::sync::Arc;
|
|
|
|
use itertools::Itertools;
|
|
|
|
use crate::interner::{deintern, Tok};
|
|
use crate::location::Pos;
|
|
use crate::api;
|
|
|
|
/// A point of interest in resolving the error, such as the point where
|
|
/// processing got stuck, a command that is likely to be incorrect
|
|
#[derive(Clone, Debug)]
|
|
pub struct ErrPos {
|
|
/// The suspected origin
|
|
pub position: Pos,
|
|
/// Any information about the role of this origin
|
|
pub message: Option<Arc<String>>,
|
|
}
|
|
impl ErrPos {
|
|
pub fn from_api(pel: &api::ErrLocation) -> Self {
|
|
Self {
|
|
message: Some(pel.message.clone()).filter(|s| !s.is_empty()),
|
|
position: Pos::from_api(&pel.location),
|
|
}
|
|
}
|
|
pub fn to_api(&self) -> api::ErrLocation {
|
|
api::ErrLocation {
|
|
message: self.message.clone().unwrap_or_default(),
|
|
location: self.position.to_api(),
|
|
}
|
|
}
|
|
pub fn new(msg: &str, position: Pos) -> Self {
|
|
Self { message: Some(Arc::new(msg.to_string())), position }
|
|
}
|
|
}
|
|
impl From<Pos> for ErrPos {
|
|
fn from(origin: Pos) -> Self { Self { position: origin, message: None } }
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct OrcErr {
|
|
pub description: Tok<String>,
|
|
pub message: Arc<String>,
|
|
pub positions: Vec<ErrPos>,
|
|
}
|
|
impl OrcErr {
|
|
pub fn from_api(err: &api::OrcError) -> Self {
|
|
Self {
|
|
description: deintern(err.description),
|
|
message: err.message.clone(),
|
|
positions: err.locations.iter().map(ErrPos::from_api).collect(),
|
|
}
|
|
}
|
|
pub fn to_api(&self) -> api::OrcError {
|
|
api::OrcError {
|
|
description: self.description.marker(),
|
|
message: self.message.clone(),
|
|
locations: self.positions.iter().map(ErrPos::to_api).collect(),
|
|
}
|
|
}
|
|
}
|
|
impl Eq for OrcErr {}
|
|
impl PartialEq for OrcErr {
|
|
fn eq(&self, other: &Self) -> bool { self.description == other.description }
|
|
}
|
|
impl From<OrcErr> for Vec<OrcErr> {
|
|
fn from(value: OrcErr) -> Self { vec![value] }
|
|
}
|
|
|
|
pub fn errv_to_apiv<'a>(errv: impl IntoIterator<Item = &'a OrcErr>) -> Vec<api::OrcError> {
|
|
errv.into_iter().map(OrcErr::to_api).collect_vec()
|
|
}
|
|
|
|
pub fn errv_from_apiv<'a>(err: impl IntoIterator<Item = &'a api::OrcError>) -> Vec<OrcErr> {
|
|
err.into_iter().map(OrcErr::from_api).collect()
|
|
}
|
|
|
|
pub type OrcRes<T> = Result<T, Vec<OrcErr>>;
|
|
|
|
pub fn mk_err(
|
|
description: Tok<String>,
|
|
message: impl AsRef<str>,
|
|
posv: impl IntoIterator<Item = ErrPos>,
|
|
) -> OrcErr {
|
|
OrcErr {
|
|
description,
|
|
message: Arc::new(message.as_ref().to_string()),
|
|
positions: posv.into_iter().collect(),
|
|
}
|
|
}
|
|
|
|
pub trait Reporter {
|
|
fn report(&self, e: OrcErr);
|
|
} |