vendor/regex/src/error.rs

   1 use std::fmt;
   2 use std::iter::repeat;
   3
   4 /// An error that occurred during parsing or compiling a regular expression.
   5 #[derive(Clone, PartialEq)]
   6 pub enum Error {
   7     /// A syntax error.
   8     Syntax(String),
   9     /// The compiled program exceeded the set size limit.
  10     /// The argument is the size limit imposed.
  11     CompiledTooBig(usize),
  12     /// Hints that destructuring should not be exhaustive.
  13     ///
  14     /// This enum may grow additional variants, so this makes sure clients
  15     /// don't count on exhaustive matching. (Otherwise, adding a new variant
  16     /// could break existing code.)
  17     #[doc(hidden)]
  18     __Nonexhaustive,
  19 }
  20
  21 impl ::std::error::Error for Error {
  22     // TODO: Remove this method entirely on the next breaking semver release.
  23     #[allow(deprecated)]
  24     fn description(&self) -> &str {
  25         match *self {
  26             Error::Syntax(ref err) => err,
  27             Error::CompiledTooBig(_) => "compiled program too big",
  28             Error::__Nonexhaustive => unreachable!(),
  29         }
  30     }
  31 }
  32
  33 impl fmt::Display for Error {
  34     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  35         match *self {
  36             Error::Syntax(ref err) => err.fmt(f),
  37             Error::CompiledTooBig(limit) => write!(
  38                 f,
  39                 "Compiled regex exceeds size limit of {} bytes.",
  40                 limit
  41             ),
  42             Error::__Nonexhaustive => unreachable!(),
  43         }
  44     }
  45 }
  46
  47 // We implement our own Debug implementation so that we show nicer syntax
  48 // errors when people use `Regex::new(...).unwrap()`. It's a little weird,
  49 // but the `Syntax` variant is already storing a `String` anyway, so we might
  50 // as well format it nicely.
  51 impl fmt::Debug for Error {
  52     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  53         match *self {
  54             Error::Syntax(ref err) => {
  55                 let hr: String = repeat('~').take(79).collect();
  56                 writeln!(f, "Syntax(")?;
  57                 writeln!(f, "{}", hr)?;
  58                 writeln!(f, "{}", err)?;
  59                 writeln!(f, "{}", hr)?;
  60                 write!(f, ")")?;
  61                 Ok(())
  62             }
  63             Error::CompiledTooBig(limit) => {
  64                 f.debug_tuple("CompiledTooBig").field(&limit).finish()
  65             }
  66             Error::__Nonexhaustive => {
  67                 f.debug_tuple("__Nonexhaustive").finish()
  68             }
  69         }
  70     }
  71 }