use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Severity {
Error,
Warning,
Info,
Debug,
}
impl Severity {
pub fn word(self) -> &'static str {
match self {
Severity::Error => "error",
Severity::Warning => "warning",
Severity::Info => "info",
Severity::Debug => "debug",
}
}
pub fn shown_at(self, level: Severity) -> bool {
self <= level
}
}
impl fmt::Display for Severity {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.word())
}
}
impl std::str::FromStr for Severity {
type Err = String;
fn from_str(s: &str) -> Result<Severity, String> {
match s.trim().to_ascii_lowercase().as_str() {
"error" | "errors" => Ok(Severity::Error),
"warning" | "warnings" | "warn" => Ok(Severity::Warning),
"info" | "infos" => Ok(Severity::Info),
"debug" | "all" => Ok(Severity::Debug),
other => Err(format!(
"'{other}' is no diagnostics level: error, warning, info or debug"
)),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Diagnostic {
pub severity: Severity,
pub code: String,
pub message: String,
pub site: String,
}
impl Diagnostic {
pub fn new(
severity: Severity,
code: impl Into<String>,
site: impl Into<String>,
message: impl Into<String>,
) -> Diagnostic {
let code = code.into();
debug_assert!(
{
let rows = rows_of(&code);
rows.is_empty() || rows.iter().any(|r| r.severity == severity)
},
"{code} is raised as {severity}, and langspec/diagnostics.tsv has no such row"
);
Diagnostic {
severity,
code,
message: message.into(),
site: site.into(),
}
}
pub fn error(
code: impl Into<String>,
site: impl Into<String>,
message: impl Into<String>,
) -> Diagnostic {
Diagnostic::new(Severity::Error, code, site, message)
}
pub fn warning(
code: impl Into<String>,
site: impl Into<String>,
message: impl Into<String>,
) -> Diagnostic {
Diagnostic::new(Severity::Warning, code, site, message)
}
pub fn info(
code: impl Into<String>,
site: impl Into<String>,
message: impl Into<String>,
) -> Diagnostic {
Diagnostic::new(Severity::Info, code, site, message)
}
pub fn line(&self) -> String {
let head = self.head();
match self.tail() {
Some(tail) if self.message.ends_with('.') => format!("{head} {tail}"),
Some(tail) => format!("{head}. {tail}"),
None => head,
}
}
pub fn head(&self) -> String {
format!(
"{} {} ({}): {}",
self.severity, self.code, self.site, self.message
)
}
pub fn tail(&self) -> Option<String> {
let row = row_of(&self.code, self.severity)?;
(!row.lead.is_empty()).then(|| format!("{}: {} {}", row.lead, manual_door(), self.code))
}
}
const INVENTORY: &str = include_str!("syntax/diagnostics.tsv");
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Row {
pub code: &'static str,
pub severity: Severity,
pub family: &'static str,
pub remedy: &'static str,
pub lead: &'static str,
pub raised_en: &'static str,
pub raised_ru: &'static str,
pub remedy_en: &'static str,
pub remedy_ru: &'static str,
}
pub fn inventory() -> &'static [Row] {
static ROWS: std::sync::OnceLock<Vec<Row>> = std::sync::OnceLock::new();
ROWS.get_or_init(|| parse_inventory(INVENTORY))
}
fn parse_inventory(text: &'static str) -> Vec<Row> {
let header: Vec<&str> = text
.lines()
.find(|l| l.starts_with("# code\t"))
.map(|l| l.trim_start_matches("# ").split('\t').collect())
.unwrap_or_default();
let at = |name: &str| header.iter().position(|h| *h == name);
let (code, severity, family, remedy) = (at("code"), at("severity"), at("family"), at("remedy"));
let (lead, raised_en, raised_ru) = (at("lead_en"), at("raised_en"), at("raised_ru"));
let (remedy_en, remedy_ru) = (at("remedy_en"), at("remedy_ru"));
text.lines()
.filter(|l| !l.starts_with('#') && !l.trim().is_empty())
.filter_map(|l| {
let cells: Vec<&'static str> = l.split('\t').collect();
let cell = |i: Option<usize>| i.and_then(|i| cells.get(i).copied()).unwrap_or("");
Some(Row {
code: cell(code),
severity: cell(severity).parse().ok()?,
family: cell(family),
remedy: cell(remedy),
lead: cell(lead),
raised_en: cell(raised_en),
raised_ru: cell(raised_ru),
remedy_en: cell(remedy_en),
remedy_ru: cell(remedy_ru),
})
})
.collect()
}
pub fn rows_of(code: &str) -> Vec<&'static Row> {
inventory().iter().filter(|r| r.code == code).collect()
}
pub fn row_of(code: &str, severity: Severity) -> Option<&'static Row> {
let rows = rows_of(code);
rows.iter()
.find(|r| r.severity == severity)
.or(rows.first())
.copied()
}
pub fn translator_refusal(
bridge: &str,
code: &str,
reason: &str,
lenient_takes: bool,
lenient_on: bool,
) -> String {
let d = Diagnostic::error(code, bridge, reason);
let by_flag = row_of(code, Severity::Error).is_some_and(|r| r.remedy == "lenient");
if by_flag && (!lenient_takes || lenient_on) {
d.head()
} else {
d.line()
}
}
static MANUAL_DOOR: std::sync::RwLock<&'static str> = std::sync::RwLock::new("qua man");
pub fn set_manual_door(door: &'static str) {
if let Ok(mut d) = MANUAL_DOOR.write() {
*d = door;
}
}
fn manual_door() -> &'static str {
MANUAL_DOOR.read().map(|d| *d).unwrap_or("qua man")
}
impl fmt::Display for Diagnostic {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.line())
}
}
macro_rules! codes {
($($(#[$doc:meta])* $name:ident),* $(,)?) => {
$($(#[$doc])* pub const $name: &str = stringify!($name);)*
pub const CODES: &[&str] = &[$($name),*];
};
}
codes! {
REFUSED,
OMITTED,
SYNTAX,
QUANTIFIER_BOUND,
FRONTIER_BOUND,
WALK,
NOT_NUMERIC,
UNKNOWN_LABEL,
UNKNOWN_PROPERTY,
UNKNOWN_FIELD,
UNREADABLE_SHEET,
SEVERAL_WITNESSES,
INDEX_CAST,
RANDOM_SEED,
TRANSPOSE_CAST,
GRAPH_BOUND,
NAVIGATION_RESTARTED,
UNSUPPORTED,
EXPANSION,
PUSHED,
DELEGATED,
LOCALE,
LOCALE_UNKNOWN,
AUTOUNITS,
CORRELATE,
TABLE_TEXT,
UNINDEXED,
LENIENT_TRANSLATION,
UNRESOLVED,
READING,
COPIED,
PLAN,
MOUNT,
ERROR,
SORT_NOT_PUSHED,
FOLD_NOT_PUSHED,
UNIQUE_NOT_PUSHED,
TAKE_NOT_PUSHED,
NEGATION_NOT_PUSHED,
PATTERN_NOT_PUSHED,
RESOLUTION_NOT_PUSHED,
WALK_NOT_PUSHED,
STATE_NOT_PUSHED,
JOIN_NOT_PUSHED,
REDUCER_NOT_PUSHED,
TYPE_NOT_PUSHED,
UNION_NOT_PUSHED,
OPERATOR_NOT_PUSHED,
NAME_NOT_PUSHED,
GRAFT_NOT_PUSHED,
OPTION_NOT_PUSHED,
STATEMENT_NOT_PUSHED,
GRAPH_NOT_PUSHED,
CONDITION_NOT_PUSHED,
CONSTRUCT_NOT_TRANSLATED,
DESCENT_NOT_TRANSLATED,
SLICE_NOT_TRANSLATED,
VALUES_NOT_TRANSLATED,
MAP_NOT_TRANSLATED,
FUNCTION_NOT_TRANSLATED,
SORT_NOT_TRANSLATED,
LITERAL_NOT_TRANSLATED,
PATH_NOT_TRANSLATED,
AXIS_NOT_TRANSLATED,
NODE_TEST_NOT_TRANSLATED,
ATTRIBUTE_NOT_TRANSLATED,
POSITION_NOT_TRANSLATED,
STATEMENT_NOT_TRANSLATED,
JOIN_NOT_TRANSLATED,
DISTINCT_NOT_TRANSLATED,
GROUP_NOT_TRANSLATED,
HAVING_NOT_TRANSLATED,
UNION_NOT_TRANSLATED,
NULL_NOT_TRANSLATED,
NAME_NOT_TRANSLATED,
AGGREGATE_NOT_TRANSLATED,
}
pub const OMITTED_TEXT: &str = "some data is omitted due to insufficient permissions";
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn levels_and_lines() {
assert!(Severity::Error.shown_at(Severity::Error));
assert!(!Severity::Warning.shown_at(Severity::Error));
assert!(Severity::Warning.shown_at(Severity::Warning));
assert!(Severity::Info.shown_at(Severity::Info));
assert!(!Severity::Info.shown_at(Severity::Warning));
assert!(Severity::Debug.shown_at(Severity::Debug));
assert!(!Severity::Debug.shown_at(Severity::Info));
assert_eq!("debug".parse::<Severity>().unwrap(), Severity::Debug);
assert_eq!("warn".parse::<Severity>().unwrap(), Severity::Warning);
assert!("loud".parse::<Severity>().is_err());
let d = Diagnostic::error(SYNTAX, "query", "an open bracket");
assert_eq!(d.to_string(), "error SYNTAX (query): an open bracket");
}
#[test]
fn a_line_ends_with_the_door_to_its_remedy() {
let d = Diagnostic::info(
SORT_NOT_PUSHED,
"query",
"ORDER BY collations differ per engine; scanning",
);
assert_eq!(
d.to_string(),
"info SORT_NOT_PUSHED (query): ORDER BY collations differ per engine; scanning. \
Narrow first: qua man SORT_NOT_PUSHED"
);
assert_eq!(Diagnostic::info(LOCALE, "run", "C").tail(), None);
assert_eq!(Diagnostic::info("NO_SUCH_CODE", "run", "x").tail(), None);
}
#[test]
fn every_code_has_a_row_and_every_row_a_code() {
let rows: std::collections::BTreeSet<&str> = inventory().iter().map(|r| r.code).collect();
let codes: std::collections::BTreeSet<&str> = CODES.iter().copied().collect();
assert_eq!(codes.len(), CODES.len(), "a code listed twice");
let unlisted: Vec<&&str> = codes.difference(&rows).collect();
let unraised: Vec<&&str> = rows.difference(&codes).collect();
assert!(
unlisted.is_empty() && unraised.is_empty(),
"codes with no row in langspec/diagnostics.tsv: {unlisted:?}; rows no code raises: \
{unraised:?}"
);
for r in inventory() {
assert!(
!r.family.is_empty() && !r.raised_en.is_empty() && !r.raised_ru.is_empty(),
"{r:?}"
);
assert_eq!(
r.lead.is_empty(),
r.remedy == "none",
"a lead goes with a remedy: {r:?}"
);
}
}
}