wip: Pretty display error info

CosmicHorrorDev · CosmicHorrorDev · commit 1d0e670c8bb1 · 2024-11-19T23:34:05.000-07:00
diff --git a/keyvalues-parser/src/error.rs b/keyvalues-parser/src/error.rs
@@ -35,9 +35,24 @@ impl std::error::Error for RenderError {}
 /// An alias for `Result` with an [`Error`]
 pub type ParseResult<T> = std::result::Result<T, ParseError>;
 
+#[derive(Clone, Debug)]
+pub struct ParseError {
+    pub kind: ParseErrorKind,
+    pub span: Span,
+    line: String,
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        todo!();
+    }
+}
+
+impl std::error::Error for ParseError {}
+
 /// Errors encountered while parsing VDF text
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum ParseError {
+pub enum ParseErrorKind {
     LingeringBytes,
     InvalidMacro,
     MissingTopLevelPair,
@@ -48,7 +63,7 @@ pub enum ParseError {
     InvalidComment,
 }
 
-impl fmt::Display for ParseError {
+impl fmt::Display for ParseErrorKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::LingeringBytes => f.write_str("Bytes remained after parsed pair"),
@@ -65,4 +80,20 @@ impl fmt::Display for ParseError {
     }
 }
 
-impl std::error::Error for ParseError {}
+#[derive(Clone, Debug)]
+pub enum Span {
+    Single(usize),
+    Run { index: usize, len: usize },
+}
+
+impl Span {
+    pub(crate) fn run_with_len(index: usize, len: usize) -> Self {
+        Span::Run { index, len }
+    }
+}
+
+impl From<usize> for Span {
+    fn from(index: usize) -> Self {
+        Self::Single(index)
+    }
+}
diff --git a/keyvalues-parser/src/text/parse.rs b/keyvalues-parser/src/text/parse.rs
@@ -1,7 +1,7 @@
 use std::{borrow::Cow, str::Chars};
 
 use crate::{
-    error::{ParseError, ParseResult},
+    error::{ParseError, ParseErrorKind, ParseResult, Span},
     Key, Obj, PartialVdf, Value, Vdf,
 };
 
@@ -51,7 +51,7 @@ pub fn parse_(s: &str, escape_chars: bool) -> ParseResult<PartialVdf> {
     eat_comments_whitespace_and_newlines(&mut chars)?;
 
     if chars.peek().is_some() {
-        Err(ParseError::LingeringBytes)
+        Err(chars.err(ParseErrorKind::LingeringBytes, 0.into()))
     } else {
         Ok(PartialVdf { bases, key, value })
     }
@@ -79,7 +79,7 @@ fn parse_maybe_macro<'text>(
     }
 
     if !eat_whitespace(chars) {
-        return Err(ParseError::InvalidMacro);
+        return Err(chars.err(ParseErrorKind::InvalidMacro, 0.into()));
     }
 
     let macro_ = parse_quoted_raw_or_unquoted_string(chars)?;
@@ -90,7 +90,7 @@ fn parse_maybe_macro<'text>(
     if eat_newlines(chars) {
         Ok(Some(()))
     } else {
-        Err(ParseError::MissingTopLevelPair)
+        Err(chars.err(ParseErrorKind::MissingTopLevelPair, 0.into()))
     }
 }
 
@@ -108,17 +108,24 @@ fn parse_quoted_raw_or_unquoted_string<'text>(
 fn parse_quoted_raw_string<'text>(chars: &mut CharIter<'text>) -> ParseResult<&'text str> {
     assert!(chars.ensure_next('"'));
     let start_idx = chars.index();
-    while chars.next().ok_or(ParseError::EoiParsingString)? != '"' {}
+    while chars
+        .next()
+        .ok_or_else(|| chars.err(ParseErrorKind::EoiParsingString, 0.into()))?
+        != '"'
+    {}
     let end_idx = chars.index() - '"'.len_utf8();
     Ok(&chars.original_str()[start_idx..end_idx])
 }
 
 fn parse_unquoted_string<'text>(chars: &mut CharIter<'text>) -> ParseResult<&'text str> {
     let start_idx = chars.index();
 
-    match chars.next().ok_or(ParseError::EoiParsingString)? {
+    match chars
+        .next()
+        .ok_or_else(|| chars.err(ParseErrorKind::EoiParsingString, 0.into()))?
+    {
         '"' | '{' | '}' | ' ' | '\t' | '\r' | '\n' => {
-            return Err(ParseError::ExpectedUnquotedString)
+            return Err(chars.err(ParseErrorKind::ExpectedUnquotedString, 0.into()))
         }
         _ => {}
     }
@@ -162,7 +169,9 @@ fn parse_quoted_string<'text>(
 
     let start_idx = chars.index();
     loop {
-        let peeked = chars.peek().ok_or(ParseError::EoiParsingString)?;
+        let peeked = chars
+            .peek()
+            .ok_or_else(|| chars.err(ParseErrorKind::EoiParsingString, 0.into()))?;
         // We only care about potential escaped characters if `escape_chars` is set. Otherwise we
         // only break on " for a quoted string
         if peeked == '"' || (peeked == '\\' && escape_chars) {
@@ -175,23 +184,32 @@ fn parse_quoted_string<'text>(
     let text_chunk = &chars.original_str()[start_idx..end_idx];
     // If our string contains escaped characters then it has to be a `Cow::Owned` otherwise it can
     // be `Cow::Borrowed`
-    let key = if chars.peek().ok_or(ParseError::EoiParsingString)? == '"' {
+    let key = if chars
+        .peek()
+        .ok_or_else(|| chars.err(ParseErrorKind::EoiParsingString, 0.into()))?
+        == '"'
+    {
         assert!(chars.ensure_next('"'));
         Cow::Borrowed(text_chunk)
     } else {
         assert!(chars.peek().unwrap() == '\\');
         let mut escaped = text_chunk.to_owned();
         loop {
-            let ch = chars.next().ok_or(ParseError::InvalidEscapedCharacter)?;
+            let ch = chars
+                .next()
+                .ok_or_else(|| chars.err(ParseErrorKind::InvalidEscapedCharacter, 0.into()))?;
             match ch {
                 '"' => break Cow::Owned(escaped),
-                '\\' => match chars.next().ok_or(ParseError::InvalidEscapedCharacter)? {
+                '\\' => match chars
+                    .next()
+                    .ok_or_else(|| chars.err(ParseErrorKind::InvalidEscapedCharacter, 0.into()))?
+                {
                     'n' => escaped.push('\n'),
                     'r' => escaped.push('\r'),
                     't' => escaped.push('\t'),
                     '\\' => escaped.push('\\'),
                     '\"' => escaped.push('\"'),
-                    _ => return Err(ParseError::InvalidEscapedCharacter),
+                    _ => return Err(chars.err(ParseErrorKind::InvalidEscapedCharacter, 0.into())),
                 },
                 regular => escaped.push(regular),
             }
@@ -224,7 +242,11 @@ fn parse_obj<'text>(chars: &mut CharIter<'text>, escape_chars: bool) -> ParseRes
 
     let mut obj = Obj::new();
 
-    while chars.peek().ok_or(ParseError::EoiParsingMap)? != '}' {
+    while chars
+        .peek()
+        .ok_or_else(|| chars.err(ParseErrorKind::EoiParsingMap, 0.into()))?
+        != '}'
+    {
         let Vdf { key, value } = parse_pair(chars, escape_chars)?;
         obj.0.entry(key).or_default().push(value);
 
@@ -273,13 +295,13 @@ fn eat_comments(chars: &mut CharIter<'_>) -> ParseResult<bool> {
                     chars.unwrap_next();
                     match chars.next() {
                         Some('\n') => break,
-                        _ => return Err(ParseError::InvalidComment),
+                        _ => return Err(chars.err(ParseErrorKind::InvalidComment, 0.into())),
                     }
                 }
                 None | Some('\n') => break,
                 // Various control characters
                 Some('\u{00}'..='\u{08}' | '\u{0A}'..='\u{1F}' | '\u{7F}') => {
-                    return Err(ParseError::InvalidComment);
+                    return Err(chars.err(ParseErrorKind::InvalidComment, 0.into()));
                 }
                 _ => _ = chars.unwrap_next(),
             }
@@ -403,6 +425,11 @@ impl<'text> CharIter<'text> {
         }
         arr
     }
+
+    #[must_use]
+    fn err(&self, kind: ParseErrorKind, span: Span) -> ParseError {
+        todo!();
+    }
 }
 
 impl Iterator for CharIter<'_> {
