refactor: use std::ops::ControlFlow

1 files changed, 39 insertions, 32 deletions

diff --git a/src/tokenizer/mod.rs b/src/tokenizer/mod.rs
index e54eb46..02f7963 100644
--- a/src/tokenizer/mod.rs
+++ b/src/tokenizer/mod.rs
@@ -27,6 +27,7 @@ use std::borrow::Cow::{self, Borrowed};
 use std::collections::BTreeMap;
 use std::default::Default;
 use std::mem::replace;
+use std::ops::ControlFlow;
 
 pub use crate::util::buffer_queue::BufferQueue;
 use crate::util::buffer_queue::{FromSet, NotFromSet, SetResult};
@@ -37,7 +38,6 @@ mod interface;
 mod states;
 
 pub enum ProcessResult<Handle> {
-    Continue,
     Suspend,
     Script(Handle),
 }
@@ -351,17 +351,21 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
                     self.state_profile.insert(state, dt);
                 }
                 match run {
-                    ProcessResult::Continue => (),
-                    ProcessResult::Suspend => break,
-                    ProcessResult::Script(node) => return TokenizerResult::Script(node),
+                    ControlFlow::Continue(()) => (),
+                    ControlFlow::Break(ProcessResult::Suspend) => break,
+                    ControlFlow::Break(ProcessResult::Script(node)) => {
+                        return TokenizerResult::Script(node)
+                    }
                 }
             }
         } else {
             loop {
                 match self.step(input) {
-                    ProcessResult::Continue => (),
-                    ProcessResult::Suspend => break,
-                    ProcessResult::Script(node) => return TokenizerResult::Script(node),
+                    ControlFlow::Continue(()) => (),
+                    ControlFlow::Break(ProcessResult::Suspend) => break,
+                    ControlFlow::Break(ProcessResult::Script(node)) => {
+                        return TokenizerResult::Script(node)
+                    }
                 }
             }
         }
@@ -401,7 +405,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
         self.process_token_and_continue(CharacterTokens(b));
     }
 
-    fn emit_current_tag(&mut self) -> ProcessResult<Sink::Handle> {
+    fn emit_current_tag(&mut self) -> ControlFlow<ProcessResult<Sink::Handle>> {
         self.finish_attribute();
 
         let name = self.current_tag_name.clone();
@@ -429,18 +433,18 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
         });
 
         match self.process_token(token) {
-            TokenSinkResult::Continue => ProcessResult::Continue,
+            TokenSinkResult::Continue => ControlFlow::Continue(()),
             TokenSinkResult::Plaintext => {
                 self.state = states::Plaintext;
-                ProcessResult::Continue
+                ControlFlow::Continue(())
             }
             TokenSinkResult::Script(node) => {
                 self.state = states::Data;
-                ProcessResult::Script(node)
+                ControlFlow::Break(ProcessResult::Script(node))
             }
             TokenSinkResult::RawData(kind) => {
                 self.state = states::RawData(kind);
-                ProcessResult::Continue
+                ControlFlow::Continue(())
             }
         }
     }
@@ -602,12 +606,12 @@ macro_rules! sh_trace ( ( $me:ident : $($cmds:tt)* ) => ( shorthand!($me: $($cmd
 
 // A little DSL for sequencing shorthand actions.
 macro_rules! go (
-    ( $me:ident : to $s:ident                    ) => ({ $me.state = states::$s; ProcessResult::Continue           });
-    ( $me:ident : to $s:ident $k1:expr           ) => ({ $me.state = states::$s($k1); ProcessResult::Continue      });
-    ( $me:ident : to $s:ident $k1:ident $k2:expr ) => ({ $me.state = states::$s($k1($k2)); ProcessResult::Continue });
+    ( $me:ident : to $s:ident                    ) => ({ $me.state = states::$s; ControlFlow::Continue(())           });
+    ( $me:ident : to $s:ident $k1:expr           ) => ({ $me.state = states::$s($k1); ControlFlow::Continue(())      });
+    ( $me:ident : to $s:ident $k1:ident $k2:expr ) => ({ $me.state = states::$s($k1($k2)); ControlFlow::Continue(()) });
 
-    ( $me:ident : consume_char_ref             ) => ({ $me.consume_char_ref(None); ProcessResult::Continue         });
-    ( $me:ident : consume_char_ref $addnl:expr ) => ({ $me.consume_char_ref(Some($addnl)); ProcessResult::Continue });
+    ( $me:ident : consume_char_ref             ) => ({ $me.consume_char_ref(None); ControlFlow::Continue(())         });
+    ( $me:ident : consume_char_ref $addnl:expr ) => ({ $me.consume_char_ref(Some($addnl)); ControlFlow::Continue(()) });
 
     // We have a default next state after emitting a tag, but the sink can override.
     ( $me:ident : emit_tag $s:ident ) => ({
@@ -629,23 +633,23 @@ macro_rules! go_match ( ( $me:ident : $x:expr, $($pats:pat),+ => $($cmds:tt)* )
 // This is a macro because it can cause early return
 // from the function where it is used.
 macro_rules! get_char ( ($me:expr, $input:expr) => (
-    unwrap_or_return!($me.get_char($input), ProcessResult::Suspend)
+    unwrap_or_return!($me.get_char($input), ControlFlow::Break(ProcessResult::Suspend))
 ));
 
 macro_rules! peek ( ($me:expr, $input:expr) => (
-    unwrap_or_return!($me.peek($input), ProcessResult::Suspend)
+    unwrap_or_return!($me.peek($input), ControlFlow::Break(ProcessResult::Suspend))
 ));
 
 macro_rules! pop_except_from ( ($me:expr, $input:expr, $set:expr) => (
-    unwrap_or_return!($me.pop_except_from($input, $set), ProcessResult::Suspend)
+    unwrap_or_return!($me.pop_except_from($input, $set), ControlFlow::Break(ProcessResult::Suspend))
 ));
 
 macro_rules! eat ( ($me:expr, $input:expr, $pat:expr) => (
-    unwrap_or_return!($me.eat($input, $pat, u8::eq_ignore_ascii_case), ProcessResult::Suspend)
+    unwrap_or_return!($me.eat($input, $pat, u8::eq_ignore_ascii_case), ControlFlow::Break(ProcessResult::Suspend))
 ));
 
 macro_rules! eat_exact ( ($me:expr, $input:expr, $pat:expr) => (
-    unwrap_or_return!($me.eat($input, $pat, u8::eq), ProcessResult::Suspend)
+    unwrap_or_return!($me.eat($input, $pat, u8::eq), ControlFlow::Break(ProcessResult::Suspend))
 ));
 
 impl<Sink: TokenSink> Tokenizer<Sink> {
@@ -653,7 +657,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
     // Return true if we should be immediately re-invoked
     // (this just simplifies control flow vs. break / continue).
     #[allow(clippy::never_loop)]
-    fn step(&mut self, input: &mut BufferQueue) -> ProcessResult<Sink::Handle> {
+    fn step(&mut self, input: &mut BufferQueue) -> ControlFlow<ProcessResult<Sink::Handle>> {
         if self.char_ref_tokenizer.is_some() {
             return self.step_char_ref_tokenizer(input);
         }
@@ -1871,7 +1875,10 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
         }
     }
 
-    fn step_char_ref_tokenizer(&mut self, input: &mut BufferQueue) -> ProcessResult<Sink::Handle> {
+    fn step_char_ref_tokenizer(
+        &mut self,
+        input: &mut BufferQueue,
+    ) -> ControlFlow<ProcessResult<Sink::Handle>> {
         // FIXME HACK: Take and replace the tokenizer so we don't
         // double-mut-borrow self.  This is why it's boxed.
         let mut tok = self.char_ref_tokenizer.take().unwrap();
@@ -1880,11 +1887,11 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
         let progress = match outcome {
             char_ref::Done => {
                 self.process_char_ref(tok.get_result());
-                return ProcessResult::Continue;
+                return ControlFlow::Continue(());
             }
 
-            char_ref::Stuck => ProcessResult::Suspend,
-            char_ref::Progress => ProcessResult::Continue,
+            char_ref::Stuck => ControlFlow::Break(ProcessResult::Suspend),
+            char_ref::Progress => ControlFlow::Continue(()),
         };
 
         self.char_ref_tokenizer = Some(tok);
@@ -1942,9 +1949,9 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
 
         loop {
             match self.eof_step() {
-                ProcessResult::Continue => (),
-                ProcessResult::Suspend => break,
-                ProcessResult::Script(_) => unreachable!(),
+                ControlFlow::Continue(()) => (),
+                ControlFlow::Break(ProcessResult::Suspend) => break,
+                ControlFlow::Break(ProcessResult::Script(_)) => unreachable!(),
             }
         }
 
@@ -1974,7 +1981,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
         }
     }
 
-    fn eof_step(&mut self) -> ProcessResult<Sink::Handle> {
+    fn eof_step(&mut self) -> ControlFlow<ProcessResult<Sink::Handle>> {
         match self.state {
             states::Data
             | states::RawData(Rcdata)
@@ -1982,7 +1989,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
             | states::RawData(ScriptData)
             | states::Plaintext => {
                 self.emit_eof();
-                ProcessResult::Suspend
+                ControlFlow::Break(ProcessResult::Suspend)
             }
 
             states::TagName