Remove unwrap_or_return! in xml5ever

xml5ever/src/macros.rs

@@ -7,22 +7,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-macro_rules! unwrap_or_return {
-    ($opt:expr) => {{
-        let Some(x) = $opt else {
-            return;
-        };
-        x
-    }};
-    ($opt:expr, $retval:expr) => {{
-        let Some(x) = $opt else {
-            return $retval;
-        };
-        x
-    }};
-}
-pub(crate) use unwrap_or_return;
-
 macro_rules! time {
     ($e:expr) => {{
         let t0 = ::std::time::Instant::now();

xml5ever/src/tokenizer/char_ref/mod.rs

@@ -9,7 +9,6 @@
 
 use super::{TokenSink, XmlTokenizer};
 use crate::data;
-use crate::macros::unwrap_or_return;
 use crate::tendril::StrTendril;
 use log::debug;
 use markup5ever::buffer_queue::BufferQueue;
@@ -138,21 +137,20 @@ impl CharRefTokenizer {
         tokenizer: &XmlTokenizer<Sink>,
         input: &BufferQueue,
     ) -> Status {
-        match unwrap_or_return!(tokenizer.peek(input), Stuck) {
-            '\t' | '\n' | '\x0C' | ' ' | '<' | '&' => self.finish_none(),
-            c if Some(c) == self.addnl_allowed => self.finish_none(),
-
-            '#' => {
+        match tokenizer.peek(input) {
+            Some('\t' | '\n' | '\x0C' | ' ' | '<' | '&') => self.finish_none(),
+            Some(c) if Some(c) == self.addnl_allowed => self.finish_none(),
+            Some('#') => {
                 tokenizer.discard_char(input);
                 self.state = Octothorpe;
                 Progress
             },
-
-            _ => {
+            Some(_) => {
                 self.state = Named;
                 self.name_buf_opt = Some(StrTendril::new());
                 Progress
             },
+            None => Stuck,
         }
     }
 
@@ -161,18 +159,17 @@ impl CharRefTokenizer {
         tokenizer: &XmlTokenizer<Sink>,
         input: &BufferQueue,
     ) -> Status {
-        let c = unwrap_or_return!(tokenizer.peek(input), Stuck);
-        match c {
-            'x' | 'X' => {
+        match tokenizer.peek(input) {
+            Some(c @ ('x' | 'X')) => {
                 tokenizer.discard_char(input);
                 self.hex_marker = Some(c);
                 self.state = Numeric(16);
             },
-
-            _ => {
+            Some(_) => {
                 self.hex_marker = None;
                 self.state = Numeric(10);
             },
+            None => return Stuck,
         }
         Progress
     }
@@ -183,7 +180,9 @@ impl CharRefTokenizer {
         base: u32,
         input: &BufferQueue,
     ) -> Status {
-        let c = unwrap_or_return!(tokenizer.peek(input), Stuck);
+        let Some(c) = tokenizer.peek(input) else {
+            return Stuck;
+        };
         match c.to_digit(base) {
             Some(n) => {
                 tokenizer.discard_char(input);
@@ -212,11 +211,12 @@ impl CharRefTokenizer {
         tokenizer: &XmlTokenizer<Sink>,
         input: &BufferQueue,
     ) -> Status {
-        match unwrap_or_return!(tokenizer.peek(input), Stuck) {
-            ';' => tokenizer.discard_char(input),
-            _ => tokenizer.emit_error(Borrowed(
+        match tokenizer.peek(input) {
+            Some(';') => tokenizer.discard_char(input),
+            Some(_) => tokenizer.emit_error(Borrowed(
                 "Semicolon missing after numeric character reference",
             )),
+            None => return Stuck,
         };
         self.finish_numeric(tokenizer)
     }
@@ -277,7 +277,9 @@ impl CharRefTokenizer {
         tokenizer: &XmlTokenizer<Sink>,
         input: &BufferQueue,
     ) -> Status {
-        let c = unwrap_or_return!(tokenizer.get_char(input), Stuck);
+        let Some(c) = tokenizer.get_char(input) else {
+            return Stuck;
+        };
         self.name_buf_mut().push_char(c);
         match data::NAMED_ENTITIES.get(&self.name_buf()[..]) {
             // We have either a full match or a prefix of one.
@@ -407,7 +409,9 @@ impl CharRefTokenizer {
         tokenizer: &XmlTokenizer<Sink>,
         input: &BufferQueue,
     ) -> Status {
-        let c = unwrap_or_return!(tokenizer.get_char(input), Stuck);
+        let Some(c) = tokenizer.get_char(input) else {
+            return Stuck;
+        };
         self.name_buf_mut().push_char(c);
         match c {
             _ if c.is_ascii_alphanumeric() => return Progress,

xml5ever/src/tokenizer/mod.rs

@@ -17,7 +17,7 @@ pub use self::interface::{
 };
 pub use crate::{LocalName, Namespace, Prefix};
 
-use crate::macros::{time, unwrap_or_return};
+use crate::macros::time;
 use crate::tendril::StrTendril;
 use crate::{buffer_queue, Attribute, QualName, SmallCharSet};
 use log::debug;
@@ -627,17 +627,26 @@ macro_rules! go (
 
 // 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::Done)
-));
+macro_rules! get_char ( ($me:expr, $input:expr) => {{
+    let Some(character) = $me.get_char($input) else {
+        return ProcessResult::Done;
+    };
+    character
+}});
 
-macro_rules! pop_except_from ( ($me:expr, $input:expr, $set:expr) => (
-    unwrap_or_return!($me.pop_except_from($input, $set), ProcessResult::Done)
-));
+macro_rules! pop_except_from ( ($me:expr, $input:expr, $set:expr) => {{
+    let Some(popped_element) = $me.pop_except_from($input, $set) else {
+        return ProcessResult::Done;
+    };
+    popped_element
+}});
 
-macro_rules! eat ( ($me:expr, $input:expr, $pat:expr) => (
-    unwrap_or_return!($me.eat($input, $pat), ProcessResult::Done)
-));
+macro_rules! eat ( ($me:expr, $input:expr, $pat:expr) => {{
+    let Some(value) = $me.eat($input, $pat) else {
+        return ProcessResult::Done;
+    };
+    value
+}});
 
 /// The result of a single tokenization operation
 pub enum ProcessResult<Handle> {

xml5ever/src/tree_builder/mod.rs

@@ -23,7 +23,6 @@ pub use self::interface::{ElemName, NodeOrText, Tracer, TreeSink};
 use self::types::*;
 use crate::interface::{self, create_element, AppendNode, Attribute, QualName};
 use crate::interface::{AppendText, ExpandedName};
-use crate::macros::unwrap_or_return;
 use crate::tokenizer::{self, EndTag, ProcessResult, StartTag, Tag, TokenSink};
 use crate::tokenizer::{Doctype, EmptyTag, Pi, ShortTag};
 use crate::{LocalName, Namespace, Prefix};
@@ -385,7 +384,10 @@ where
             #[allow(clippy::unused_unit)]
             match self.step(phase, token) {
                 XmlProcessResult::Done => {
-                    token = unwrap_or_return!(more_tokens.pop_front(), ProcessResult::Continue);
+                    let Some(popped_token) = more_tokens.pop_front() else {
+                        return ProcessResult::Continue;
+                    };
+                    token = popped_token;
                 },
                 XmlProcessResult::Reprocess(m, t) => {
                     self.phase.set(m);