summaryrefslogtreecommitdiffstats
path: root/vendor/regex/src/error.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-19 09:25:53 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-19 09:25:53 +0000
commit73e0a5b7696ea019ba35b89f38fc8e7b285d99cb (patch)
tree0d2e175af6f114cb50a675bec0bc76e12e1bceb4 /vendor/regex/src/error.rs
parentAdding upstream version 1.75.0+dfsg1. (diff)
downloadrustc-upstream.tar.xz
rustc-upstream.zip
Adding upstream version 1.76.0+dfsg1.upstream/1.76.0+dfsg1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/regex/src/error.rs')
-rw-r--r--vendor/regex/src/error.rs53
1 files changed, 33 insertions, 20 deletions
diff --git a/vendor/regex/src/error.rs b/vendor/regex/src/error.rs
index 6c341f604..6026b3849 100644
--- a/vendor/regex/src/error.rs
+++ b/vendor/regex/src/error.rs
@@ -1,7 +1,9 @@
-use std::fmt;
-use std::iter::repeat;
+use alloc::string::{String, ToString};
+
+use regex_automata::meta;
/// An error that occurred during parsing or compiling a regular expression.
+#[non_exhaustive]
#[derive(Clone, PartialEq)]
pub enum Error {
/// A syntax error.
@@ -27,29 +29,44 @@ pub enum Error {
/// approaches may be appropriate. Instead, you'll have to determine just
/// how big of a regex you want to allow.
CompiledTooBig(usize),
- /// Hints that destructuring should not be exhaustive.
- ///
- /// This enum may grow additional variants, so this makes sure clients
- /// don't count on exhaustive matching. (Otherwise, adding a new variant
- /// could break existing code.)
- #[doc(hidden)]
- __Nonexhaustive,
}
-impl ::std::error::Error for Error {
+impl Error {
+ pub(crate) fn from_meta_build_error(err: meta::BuildError) -> Error {
+ if let Some(size_limit) = err.size_limit() {
+ Error::CompiledTooBig(size_limit)
+ } else if let Some(ref err) = err.syntax_error() {
+ Error::Syntax(err.to_string())
+ } else {
+ // This is a little suspect. Technically there are more ways for
+ // a meta regex to fail to build other than "exceeded size limit"
+ // and "syntax error." For example, if there are too many states
+ // or even too many patterns. But in practice this is probably
+ // good enough. The worst thing that happens is that Error::Syntax
+ // represents an error that isn't technically a syntax error, but
+ // the actual message will still be shown. So... it's not too bad.
+ //
+ // We really should have made the Error type in the regex crate
+ // completely opaque. Rookie mistake.
+ Error::Syntax(err.to_string())
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
// TODO: Remove this method entirely on the next breaking semver release.
#[allow(deprecated)]
fn description(&self) -> &str {
match *self {
Error::Syntax(ref err) => err,
Error::CompiledTooBig(_) => "compiled program too big",
- Error::__Nonexhaustive => unreachable!(),
}
}
}
-impl fmt::Display for Error {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Display for Error {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match *self {
Error::Syntax(ref err) => err.fmt(f),
Error::CompiledTooBig(limit) => write!(
@@ -57,7 +74,6 @@ impl fmt::Display for Error {
"Compiled regex exceeds size limit of {} bytes.",
limit
),
- Error::__Nonexhaustive => unreachable!(),
}
}
}
@@ -66,11 +82,11 @@ impl fmt::Display for Error {
// errors when people use `Regex::new(...).unwrap()`. It's a little weird,
// but the `Syntax` variant is already storing a `String` anyway, so we might
// as well format it nicely.
-impl fmt::Debug for Error {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Debug for Error {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match *self {
Error::Syntax(ref err) => {
- let hr: String = repeat('~').take(79).collect();
+ let hr: String = core::iter::repeat('~').take(79).collect();
writeln!(f, "Syntax(")?;
writeln!(f, "{}", hr)?;
writeln!(f, "{}", err)?;
@@ -81,9 +97,6 @@ impl fmt::Debug for Error {
Error::CompiledTooBig(limit) => {
f.debug_tuple("CompiledTooBig").field(&limit).finish()
}
- Error::__Nonexhaustive => {
- f.debug_tuple("__Nonexhaustive").finish()
- }
}
}
}