Implement Regex::source_and_options_equals

regex-automata/src/util/syntax.rs

@@ -141,7 +141,7 @@ pub fn parse_many_with<P: AsRef<str>>(
 /// These options are defined as a group since they apply to every regex engine
 /// in this crate. Instead of re-defining them on every engine's builder, they
 /// are instead provided here as one cohesive unit.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Config {
     case_insensitive: bool,
     multi_line: bool,

src/builders.rs

@@ -80,7 +80,11 @@ impl Builder {
             .configure(metac)
             .syntax(syntaxc)
             .build(&pattern)
-            .map(|meta| crate::Regex { meta, pattern })
+            .map(|meta| crate::Regex {
+                meta,
+                pattern,
+                syntaxc: Arc::new(self.syntaxc),
+            })
             .map_err(Error::from_meta_build_error)
     }
 

src/regex/string.rs

@@ -101,6 +101,7 @@ use crate::{error::Error, RegexBuilder};
 pub struct Regex {
     pub(crate) meta: meta::Regex,
     pub(crate) pattern: Arc<str>,
+    pub(crate) syntaxc: Arc<regex_automata::util::syntax::Config>,
 }
 
 impl core::fmt::Display for Regex {
@@ -1276,6 +1277,31 @@ impl Regex {
         &self.pattern
     }
 
+    /// Compares the source strings and compile options of two regexes,
+    /// returning true iff both are equal.
+    /// Such result implies equivalence of the regexes, but the contrary
+    /// provides no information about their equivalence.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::{Regex, RegexBuilder};
+    ///
+    /// let r1 = Regex::new(r"a+").unwrap();
+    /// let r2 = Regex::new(r"aa*").unwrap();
+    /// assert!(!r1.source_and_options_equals(&r2));
+    ///
+    /// let r3 = RegexBuilder::new(r"a+")
+    ///     .case_insensitive(true)
+    ///     .build()
+    ///     .unwrap();
+    /// assert!(!r1.source_and_options_equals(&r3));
+    /// ```
+    #[inline]
+    pub fn source_and_options_equals(&self, other: &Self) -> bool {
+        self.pattern == other.pattern && self.syntaxc == other.syntaxc
+    }
+
     /// Returns an iterator over the capture names in this regex.
     ///
     /// The iterator returned yields elements of type `Option<&str>`. That is,