Continuation PR for #256: Implement std::error::Error for errors

.gitignore

@@ -1,3 +1,4 @@
 target
 /Cargo.lock
 /.cargo/config
+.idea

procedural-masquerade/lib.rs

@@ -244,33 +244,33 @@ macro_rules! define_invoke_proc_macro {
         #[doc(hidden)]
         #[macro_export]
         macro_rules! $macro_name {
-                                    ($proc_macro_name: ident ! $paren: tt) => {
-                                        #[derive($proc_macro_name)]
-                                        #[allow(unused)]
-                                        enum ProceduralMasqueradeDummyType {
-                                            // The magic happens here.
-                                            //
-                                            // We use an `enum` with an explicit discriminant
-                                            // because that is the only case where a type definition
-                                            // can contain a (const) expression.
-                                            //
-                                            // `(0, "foo").0` evalutes to 0, with the `"foo"` part ignored.
-                                            //
-                                            // By the time the `#[proc_macro_derive]` function
-                                            // implementing `#[derive($proc_macro_name)]` is called,
-                                            // `$paren` has already been replaced with the input of this inner macro,
-                                            // but `stringify!` has not been expanded yet.
-                                            //
-                                            // This how arbitrary tokens can be inserted
-                                            // in the input to the `#[proc_macro_derive]` function.
-                                            //
-                                            // Later, `stringify!(...)` is expanded into a string literal
-                                            // which is then ignored.
-                                            // Using `stringify!` enables passing arbitrary tokens
-                                            // rather than only what can be parsed as a const expression.
-                                            Input = (0, stringify! $paren ).0
-                                        }
-                                    }
-                                }
+                                                    ($proc_macro_name: ident ! $paren: tt) => {
+                                                        #[derive($proc_macro_name)]
+                                                        #[allow(unused)]
+                                                        enum ProceduralMasqueradeDummyType {
+                                                            // The magic happens here.
+                                                            //
+                                                            // We use an `enum` with an explicit discriminant
+                                                            // because that is the only case where a type definition
+                                                            // can contain a (const) expression.
+                                                            //
+                                                            // `(0, "foo").0` evalutes to 0, with the `"foo"` part ignored.
+                                                            //
+                                                            // By the time the `#[proc_macro_derive]` function
+                                                            // implementing `#[derive($proc_macro_name)]` is called,
+                                                            // `$paren` has already been replaced with the input of this inner macro,
+                                                            // but `stringify!` has not been expanded yet.
+                                                            //
+                                                            // This how arbitrary tokens can be inserted
+                                                            // in the input to the `#[proc_macro_derive]` function.
+                                                            //
+                                                            // Later, `stringify!(...)` is expanded into a string literal
+                                                            // which is then ignored.
+                                                            // Using `stringify!` enables passing arbitrary tokens
+                                                            // rather than only what can be parsed as a const expression.
+                                                            Input = (0, stringify! $paren ).0
+                                                        }
+                                                    }
+                                                }
     };
 }

src/parser.rs

@@ -5,6 +5,8 @@
 use crate::cow_rc_str::CowRcStr;
 use crate::tokenizer::{SourceLocation, SourcePosition, Token, Tokenizer};
 use smallvec::SmallVec;
+use std::error::Error;
+use std::fmt;
 use std::ops::BitOr;
 use std::ops::Range;
 
@@ -53,6 +55,20 @@ pub enum BasicParseErrorKind<'i> {
     QualifiedRuleInvalid,
 }
 
+impl<'i> BasicParseErrorKind<'i> {
+    fn description(&self) -> String {
+        match self {
+            BasicParseErrorKind::UnexpectedToken(token) => {
+                format!("Unexpected token: '{}'", token.description())
+            }
+            BasicParseErrorKind::EndOfInput => "End of input".to_owned(),
+            BasicParseErrorKind::AtRuleInvalid(message) => format!("Invalid @ rule: {}", message),
+            BasicParseErrorKind::AtRuleBodyInvalid => "Invalid @ rule body".to_owned(),
+            BasicParseErrorKind::QualifiedRuleInvalid => "Invalid qualified rule".to_owned(),
+        }
+    }
+}
+
 /// The funamental parsing errors that can be triggered by built-in parsing routines.
 #[derive(Clone, Debug, PartialEq)]
 pub struct BasicParseError<'i> {
@@ -62,6 +78,18 @@ pub struct BasicParseError<'i> {
     pub location: SourceLocation,
 }
 
+impl<'i> fmt::Display for BasicParseError<'i> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(self.kind.description().as_str())
+    }
+}
+
+impl<'i> Error for BasicParseError<'i> {
+    fn description(&self) -> &str {
+        "A BasicParseError has occurred, please use the Display trait to determine it's kind"
+    }
+}
+
 impl<'i, T> From<BasicParseError<'i>> for ParseError<'i, T> {
     #[inline]
     fn from(this: BasicParseError<'i>) -> ParseError<'i, T> {
@@ -156,6 +184,27 @@ impl<'i, T> ParseError<'i, T> {
     }
 }
 
+impl<'i, T> fmt::Display for ParseError<'i, T>
+where
+    T: fmt::Display,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match &self.kind {
+            ParseErrorKind::Basic(basic_kind) => formatter.write_str(&basic_kind.description()),
+            ParseErrorKind::Custom(custom_type) => custom_type.fmt(formatter),
+        }
+    }
+}
+
+impl<'i, T> Error for ParseError<'i, T>
+where
+    T: Error,
+{
+    fn description(&self) -> &str {
+        "A ParseError has occurred, please use the Display trait to determine it's kind"
+    }
+}
+
 /// The owned input for a parser.
 pub struct ParserInput<'i> {
     tokenizer: Tokenizer<'i>,

src/tokenizer.rs

@@ -191,6 +191,68 @@ impl<'a> Token<'a> {
             BadUrl(_) | BadString(_) | CloseParenthesis | CloseSquareBracket | CloseCurlyBracket
         )
     }
+
+    pub(crate) fn description(&self) -> String {
+        match self {
+            Ident(name) => format!("A ident token '{}'", name),
+            AtKeyword(value) => format!("The value '{}' does not include the `@` marker", value),
+            Hash(value) => format!("The value '{}' does not include the `#` marker", value),
+            IDHash(value) => format!(
+                "The value '{}' does not include the `#` marker, but has a valid ID selector",
+                value
+            ),
+            QuotedString(value) => format!("The value '{}' does not include the quotes", value),
+            UnquotedUrl(value) => format!(
+                "The value '{}' does not include the `url(` `)` markers.",
+                value
+            ),
+            Delim(character) => format!("'{}'", character),
+            Number {
+                has_sign, value, ..
+            } => {
+                let sign = if has_sign.clone() { '-' } else { '+' };
+                format!("{}{}", sign, value.to_string())
+            }
+            Percentage {
+                has_sign,
+                unit_value,
+                ..
+            } => {
+                let sign = if has_sign.clone() { '-' } else { '+' };
+                format!("{}{}%", sign, unit_value.to_string())
+            }
+            Dimension {
+                has_sign,
+                value,
+                unit,
+                ..
+            } => {
+                let sign = if has_sign.clone() { '-' } else { '+' };
+                format!("{}{} {}", sign, value.to_string(), unit)
+            }
+            WhiteSpace(whitespace) => format!("whitespace: '{}'", whitespace),
+            Comment(comment) => format!("The comment: '{}'", comment),
+            Colon => String::from(":"),
+            Semicolon => String::from(";"),
+            Comma => String::from(","),
+            IncludeMatch => String::from("~="),
+            DashMatch => String::from("|="),
+            PrefixMatch => String::from("^="),
+            SuffixMatch => String::from("$="),
+            SubstringMatch => String::from("*="),
+            CDO => String::from("<!--"),
+            CDC => String::from("-->"),
+            Function(name) => format!("The value ({}) does not include the `(` marker", name),
+            ParenthesisBlock => String::from("("),
+            SquareBracketBlock => String::from("["),
+            CurlyBracketBlock => String::from("{"),
+            BadUrl(url) => format!("Bad url: '{}'", url),
+            BadString(string) => format!("Bad string: '{}'", string),
+            CloseParenthesis => "Unclosed parenthesis".to_owned(),
+            CloseSquareBracket => "Unclosed square bracket".to_owned(),
+            CloseCurlyBracket => "Unclosed curly bracket".to_owned(),
+        }
+    }
 }
 
 #[derive(Clone)]