use rowan::{TextRange, TextSize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Severity {
Error,
Warning,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Code {
UnexpectedCharacter,
BadString,
UnterminatedComment,
NoModule,
MissingModuleEnd,
UnexpectedToken,
MissingExpression,
PrecedenceConflict,
MissingOperator,
MisplacedOperator,
JunctionIndentation,
StepLevel,
StepNumberMisuse,
UnexpectedProof,
ProofTooDeep,
BadLabel,
LabelChangesParse,
TimesAsArgument,
SetMapWithIn,
AtInExcept,
BadFairness,
NewWithArguments,
BadStructuralSelector,
NestingTooDeep,
InputTooLarge,
ModuleNameMismatch,
InvalidUtf8,
}
impl Code {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::UnexpectedCharacter => "DIVE-S0001",
Self::BadString => "DIVE-S0002",
Self::UnterminatedComment => "DIVE-S0003",
Self::NoModule => "DIVE-S0004",
Self::MissingModuleEnd => "DIVE-S0005",
Self::UnexpectedToken => "DIVE-S0010",
Self::MissingExpression => "DIVE-S0011",
Self::PrecedenceConflict => "DIVE-S0012",
Self::MissingOperator => "DIVE-S0013",
Self::MisplacedOperator => "DIVE-S0014",
Self::JunctionIndentation => "DIVE-S0015",
Self::StepLevel => "DIVE-S0020",
Self::StepNumberMisuse => "DIVE-S0021",
Self::UnexpectedProof => "DIVE-S0022",
Self::ProofTooDeep => "DIVE-S0023",
Self::BadLabel => "DIVE-S0030",
Self::LabelChangesParse => "DIVE-S0031",
Self::TimesAsArgument => "DIVE-S0032",
Self::SetMapWithIn => "DIVE-S0033",
Self::AtInExcept => "DIVE-S0034",
Self::BadFairness => "DIVE-S0035",
Self::NewWithArguments => "DIVE-S0036",
Self::BadStructuralSelector => "DIVE-S0037",
Self::NestingTooDeep => "DIVE-S0040",
Self::InputTooLarge => "DIVE-S0041",
Self::ModuleNameMismatch => "DIVE-S0006",
Self::InvalidUtf8 => "DIVE-S0007",
}
}
}
impl std::fmt::Display for Code {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Diagnostic {
pub code: Code,
pub severity: Severity,
pub message: String,
pub range: TextRange,
pub help: Option<String>,
}
impl Diagnostic {
pub(crate) fn error(code: Code, range: TextRange, message: impl Into<String>) -> Self {
Self {
code,
severity: Severity::Error,
message: message.into(),
range,
help: None,
}
}
pub(crate) fn with_help(mut self, help: impl Into<String>) -> Self {
self.help = Some(help.into());
self
}
#[must_use]
pub fn is_error(&self) -> bool {
self.severity == Severity::Error
}
}
#[must_use]
pub fn line_col(src: &str, offset: TextSize) -> (u32, u32) {
let offset = usize::from(offset).min(src.len());
let mut line = 1u32;
let mut col = 1u32;
for (i, c) in src.char_indices() {
if i >= offset {
break;
}
if c == '\n' {
line += 1;
col = 1;
} else {
col += 1;
}
}
(line, col)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn codes_are_unique() {
let all = [
Code::UnexpectedCharacter,
Code::BadString,
Code::UnterminatedComment,
Code::NoModule,
Code::MissingModuleEnd,
Code::UnexpectedToken,
Code::MissingExpression,
Code::PrecedenceConflict,
Code::MissingOperator,
Code::MisplacedOperator,
Code::JunctionIndentation,
Code::StepLevel,
Code::StepNumberMisuse,
Code::UnexpectedProof,
Code::ProofTooDeep,
Code::BadLabel,
Code::LabelChangesParse,
Code::TimesAsArgument,
Code::SetMapWithIn,
Code::AtInExcept,
Code::BadFairness,
Code::NewWithArguments,
Code::BadStructuralSelector,
Code::NestingTooDeep,
Code::InputTooLarge,
Code::ModuleNameMismatch,
Code::InvalidUtf8,
];
let mut seen = std::collections::BTreeSet::new();
for c in all {
assert!(seen.insert(c.as_str()), "{c}");
assert!(c.as_str().starts_with("DIVE-S"));
}
}
#[test]
fn line_col_counts_chars() {
assert_eq!(line_col("ab\ncd", TextSize::from(4)), (2, 2));
assert_eq!(line_col("∧x", TextSize::from(3)), (1, 2));
}
}