remove oblivion in favor of is_empty

metaborg · Nov 20, 2023 · 8361f47 · 8361f47
1 parent 44d5d1e
commit 8361f47
Show file tree

Hide file tree

Showing 5 changed files with 0 additions and 35 deletions.
diff --git a/scopegraphs-regular-expressions/src/compile.rs b/scopegraphs-regular-expressions/src/compile.rs
@@ -10,7 +10,6 @@ pub type StateID = usize;
 pub struct MatchState {
     non_final: bool,
     nullable: bool,
-    empty: bool,
     pub transition_table: HashMap<Rc<Symbol>, StateID>,
     #[cfg(feature = "dynamic")]
     pub string_transition_table: HashMap<String, StateID>,
@@ -26,10 +25,6 @@ impl MatchState {
     pub fn is_accepting(&self) -> bool {
         self.nullable
     }
-
-    pub fn is_oblivion(&self) -> bool {
-        self.empty
-    }
 }
 
 pub struct Automaton {
@@ -181,14 +176,12 @@ impl RegexCompiler {
 
             let non_final = non_final.contains(state);
             let nullable = state.is_nullable();
-            let empty = state.is_oblivion();
 
             match_states.insert(
                 *state_ids.get(state).unwrap(),
                 MatchState {
                     non_final,
                     nullable,
-                    empty,
                     #[cfg(feature = "dynamic")]
                     string_transition_table: transition_table
                         .iter()

diff --git a/scopegraphs-regular-expressions/src/dynamic.rs b/scopegraphs-regular-expressions/src/dynamic.rs
@@ -45,14 +45,6 @@ impl<'a> RegexMatcher<&'a str> for DynamicMatcher<'_> {
             .map(MatchState::is_accepting)
             .unwrap_or_default()
     }
-
-    fn is_oblivion(&self) -> bool {
-        self.compiled_regex
-            .states
-            .get(self.current_state)
-            .map(MatchState::is_oblivion)
-            .unwrap_or_default()
-    }
 }
 
 impl RegexMatcher<char> for DynamicMatcher<'_> {
@@ -68,10 +60,6 @@ impl RegexMatcher<char> for DynamicMatcher<'_> {
     fn is_accepting(&self) -> bool {
         RegexMatcher::<&str>::is_accepting(self)
     }
-
-    fn is_oblivion(&self) -> bool {
-        RegexMatcher::<&str>::is_oblivion(self)
-    }
 }
 
 #[cfg(test)]

diff --git a/scopegraphs-regular-expressions/src/emit.rs b/scopegraphs-regular-expressions/src/emit.rs
@@ -39,7 +39,6 @@ impl Automaton {
 
         let finals: Vec<_> = states.iter().map(MatchState::is_final).collect();
         let accepting: Vec<_> = states.iter().map(MatchState::is_accepting).collect();
-        let oblivions: Vec<_> = states.iter().map(MatchState::is_oblivion).collect();
 
         quote!(
             struct #name {
@@ -77,15 +76,6 @@ impl Automaton {
                         _ => unreachable!(),
                     }
                 }
-
-                fn is_oblivion(&self) -> bool {
-                    match self.state {
-                        #(
-                            #ids => {return #oblivions;}
-                        ),*
-                        _ => unreachable!(),
-                    }
-                }
             }
         )
     }

diff --git a/scopegraphs-regular-expressions/src/lib.rs b/scopegraphs-regular-expressions/src/lib.rs
@@ -47,7 +47,6 @@ pub trait RegexMatcher<A> {
 
     fn is_final(&self) -> bool;
     fn is_accepting(&self) -> bool;
-    fn is_oblivion(&self) -> bool;
     fn is_empty(&self) -> bool {
         self.is_final() && !self.is_accepting()
     }

diff --git a/scopegraphs-regular-expressions/src/regex.rs b/scopegraphs-regular-expressions/src/regex.rs
@@ -168,11 +168,6 @@ impl Regex {
         }
     }
 
-    /// Returns whether this regex accepts the empty set or oblivion
-    pub fn is_oblivion(&self) -> bool {
-        matches!(self, Regex::EmptySet)
-    }
-
     /// Returns whether this regex is nullable.
     ///
     /// That's either the empty string `e`, or some regex which has the empty string in the right place, like `e | a` is nullable because `e` is nullable.