openpgp: Make PacketParserResult a std::result::Result.

  - This avoids the partial implementation imitating
    std::option::Option, replacing it with std::result::Result.

  - As a benefit, std::result::Result is in the prelude, simplifying a
    lot of parsing loops.

23 files changed, 146 insertions, 217 deletions

diff --git a/autocrypt/src/lib.rs b/autocrypt/src/lib.rs
index ca517cc0..66b7475f 100644
--- a/autocrypt/src/lib.rs
+++ b/autocrypt/src/lib.rs
@@ -29,7 +29,7 @@ use openpgp::packet::SKESK;
 use openpgp::cert::prelude::*;
 use openpgp::parse::{
     Parse,
-    PacketParserResult, PacketParser,
+    PacketParser,
 };
 use openpgp::serialize::Serialize;
 use openpgp::serialize::stream::{
@@ -568,7 +568,7 @@ impl AutocryptSetupMessage {
         // SK-ESK and a SEIP packet, which contains a Literal data
         // packet.
 
-        let pp = if let PacketParserResult::Some(pp) = ppr {
+        let pp = if let Ok(pp) = ppr {
             pp
         } else {
             return Err(
@@ -590,12 +590,12 @@ impl AutocryptSetupMessage {
         };
 
         let pp = match ppr {
-            PacketParserResult::EOF(_) =>
+            Err(_) =>
                 return Err(
                     Error::MalformedMessage(
                         "Pre-mature EOF after reading SK-ESK packet".into())
                     .into()),
-            PacketParserResult::Some(pp) => {
+            Ok(pp) => {
                 match pp.packet {
                     Packet::SEIP(_) => (),
                     ref p => return Err(
@@ -683,7 +683,7 @@ impl<'a> AutocryptSetupMessageParser<'a> {
 
         // Recurse into the SEIP packet.
         let mut ppr = self.pp.recurse()?.1;
-        if ppr.as_ref().map(|pp| pp.recursion_depth()) != Some(1) {
+        if ppr.as_ref().ok().map(|pp| pp.recursion_depth()) != Some(1) {
             return Err(
                 Error::MalformedMessage(
                     "SEIP container empty, but expected a Literal Data packet"
@@ -692,7 +692,7 @@ impl<'a> AutocryptSetupMessageParser<'a> {
         }
 
         // Get the literal data packet.
-        let (prefer_encrypt, cert) = if let PacketParserResult::Some(mut pp) = ppr {
+        let (prefer_encrypt, cert) = if let Ok(mut pp) = ppr {
             match pp.packet {
                 Packet::Literal(_) => (),
                 p => return Err(Error::MalformedMessage(
@@ -746,7 +746,7 @@ impl<'a> AutocryptSetupMessageParser<'a> {
         };
 
         // Get the MDC packet.
-        if let PacketParserResult::Some(pp) = ppr {
+        if let Ok(pp) = ppr {
             match pp.packet {
                 Packet::MDC(_) => (),
                 ref p => return
@@ -762,7 +762,7 @@ impl<'a> AutocryptSetupMessageParser<'a> {
 
         // Make sure we reached the end of the outer message.
         match ppr {
-            PacketParserResult::EOF(pp) => {
+            Err(pp) => {
                 // If we've gotten this far, then the outer message
                 // has the right sequence of packets, but we haven't
                 // carefully checked the nesting.  We do that now.
@@ -771,7 +771,7 @@ impl<'a> AutocryptSetupMessageParser<'a> {
                         "Invalid OpenPGP Message").into());
                 }
             }
-            PacketParserResult::Some(pp) =>
+            Ok(pp) =>
                 return Err(Error::MalformedMessage(
                     format!("Extraneous packet: {}.", pp.packet.tag()))
                            .into()),
diff --git a/guide/src/chapter_03.md b/guide/src/chapter_03.md
index 19a42147..d661f7b9 100644
--- a/guide/src/chapter_03.md
+++ b/guide/src/chapter_03.md
@@ -201,7 +201,7 @@ fn main() {
     let mut buf = vec![0; 1024 * 1024];
 
     let mut ppr = PacketParser::from_bytes(MESSAGE.as_bytes()).unwrap();
-    while let PacketParserResult::Some(mut pp) = ppr {
+    while let Ok(mut pp) = ppr {
         // Match on the kind of packet here while it is in the parser.
         if let openpgp::Packet::Literal(_) = pp.packet {
             // Stream the content of the literal packet.
diff --git a/openpgp-ffi/src/parse/mod.rs b/openpgp-ffi/src/parse/mod.rs
index d3ed1407..06066a9d 100644
--- a/openpgp-ffi/src/parse/mod.rs
+++ b/openpgp-ffi/src/parse/mod.rs
@@ -357,8 +357,8 @@ pub extern "C" fn pgp_packet_parser_result_tag<'a>
     let ppr = ffi_param_ref_mut!(ppr);
 
     let tag : u8 = match ppr {
-        PacketParserResult::Some(ref pp) => pp.packet.tag().into(),
-        PacketParserResult::EOF(_) => 0,
+        Ok(ref pp) => pp.packet.tag().into(),
+        Err(_) => 0,
     };
 
     tag as c_int
@@ -383,8 +383,8 @@ pub extern "C" fn pgp_packet_parser_result_packet_parser<'a>
     let ppr = ffi_param_move!(ppr);
 
     match *ppr {
-        PacketParserResult::Some(pp) => box_raw!(pp),
-        PacketParserResult::EOF(_) => {
+        Ok(pp) => box_raw!(pp),
+        Err(_) => {
             // Don't free ppr!
             forget(ppr);
             ptr::null_mut()
@@ -411,10 +411,10 @@ pub extern "C" fn pgp_packet_parser_result_eof<'a>
     let ppr = ffi_param_move!(ppr);
 
     match *ppr {
-        PacketParserResult::Some(_) => {
+        Ok(_) => {
             forget(ppr);
             ptr::null_mut()
         }
-        PacketParserResult::EOF(eof) => box_raw!(eof),
+        Err(eof) => box_raw!(eof),
     }
 }
diff --git a/openpgp/examples/notarize.rs b/openpgp/examples/notarize.rs
index f7a9842a..c1ad00be 100644
--- a/openpgp/examples/notarize.rs
+++ b/openpgp/examples/notarize.rs
@@ -8,7 +8,7 @@ extern crate sequoia_openpgp as openpgp;
 use crate::openpgp::{
     armor,
     Packet,
-    parse::{Parse, PacketParserResult},
+    parse::Parse,
     serialize::Marshal,
 };
 use crate::openpgp::serialize::stream::{Message, LiteralWriter, Signer};
@@ -78,7 +78,7 @@ fn main() {
         = openpgp::parse::PacketParser::from_reader(&mut input)
         .expect("Failed to build parser");
 
-    while let PacketParserResult::Some(mut pp) = ppr {
+    while let Ok(mut pp) = ppr {
         if let Err(err) = pp.possible_message() {
             panic!("Malformed OpenPGP message: {}", err);
         }
@@ -110,7 +110,7 @@ fn main() {
 
         ppr = pp.recurse().expect("Failed to recurse").1;
     }
-    if let PacketParserResult::EOF(eof) = ppr {
+    if let Err(eof) = ppr {
         if let Err(err) = eof.is_message() {
             panic!("Malformed OpenPGP message: {}", err)
         }
diff --git a/openpgp/examples/statistics.rs b/openpgp/examples/statistics.rs
index 1dfebe38..8f2efe8c 100644
--- a/openpgp/examples/statistics.rs
+++ b/openpgp/examples/statistics.rs
@@ -14,7 +14,7 @@ use crate::openpgp::{Packet, Fingerprint, KeyID, KeyHandle};
 use crate::openpgp::types::*;
 use crate::openpgp::packet::{user_attribute, header::BodyLength, Tag};
 use crate::openpgp::packet::signature::subpacket::SubpacketTag;
-use crate::openpgp::parse::{Parse, PacketParserResult, PacketParser};
+use crate::openpgp::parse::{Parse, PacketParser};
 use crate::openpgp::serialize::MarshalInto;
 
 fn main() {
@@ -90,7 +90,7 @@ fn main() {
             .expect("Failed to create reader");
 
         // Iterate over all packets.
-        while let PacketParserResult::Some(pp) = ppr {
+        while let Ok(pp) = ppr {
             // While the packet is in the parser, get some data for later.
             let size = match pp.header().length() {
                 &BodyLength::Full(n) => Some(n),
diff --git a/openpgp/src/cert/mod.rs b/openpgp/src/cert/mod.rs
index 861fdd83..e72db089 100644
--- a/openpgp/src/cert/mod.rs
+++ b/openpgp/src/cert/mod.rs
@@ -312,7 +312,7 @@ use super::*;
 /// ```rust
 /// # extern crate sequoia_openpgp as openpgp;
 /// # use openpgp::Result;
-/// # use openpgp::parse::{Parse, PacketParserResult, PacketParser};
+/// # use openpgp::parse::{Parse, PacketParser};
 /// use openpgp::cert::prelude::*;
 ///
 /// # fn main() { f().unwrap(); }
@@ -387,7 +387,7 @@ use super::*;
 /// # extern crate sequoia_openpgp as openpgp;
 /// # use std::convert::TryFrom;
 /// # use openpgp::Result;
-/// # use openpgp::parse::{Parse, PacketParserResult, PacketParser};
+/// # use openpgp::parse::{Parse, PacketParser};
 /// use openpgp::Cert;
 ///
 /// # fn main() { f().unwrap(); }
diff --git a/openpgp/src/cert/parser/mod.rs b/openpgp/src/cert/parser/mod.rs
index 50cc7e5a..da0194bc 100644
--- a/openpgp/src/cert/parser/mod.rs
+++ b/openpgp/src/cert/parser/mod.rs
@@ -394,7 +394,7 @@ enum PacketSource<'a, I: Iterator<Item=Packet>> {
 /// ```rust
 /// # extern crate sequoia_openpgp as openpgp;
 /// # use openpgp::Result;
-/// # use openpgp::parse::{Parse, PacketParserResult, PacketParser};
+/// # use openpgp::parse::{Parse, PacketParser};
 /// use openpgp::cert::prelude::*;
 ///
 /// # fn main() { f().unwrap(); }
@@ -441,7 +441,7 @@ impl<'a> From<PacketParserResult<'a>> for CertParser<'a, vec::IntoIter<Packet>>
     /// Initializes a `CertParser` from a `PacketParser`.
     fn from(ppr: PacketParserResult<'a>) -> Self {
         let mut parser : Self = Default::default();
-        if let PacketParserResult::Some(pp) = ppr {
+        if let Ok(pp) = ppr {
             parser.source = PacketSource::PacketParser(pp);
         }
         parser
@@ -731,7 +731,7 @@ impl<'a, I: Iterator<Item=Packet>> Iterator for CertParser<'a, I> {
 
                     match pp.next() {
                         Ok((packet, ppr)) => {
-                            if let PacketParserResult::Some(pp) = ppr {
+                            if let Ok(pp) = ppr {
                                 self.source = PacketSource::PacketParser(pp);
                             }
 
diff --git a/openpgp/src/crypto/s2k.rs b/openpgp/src/crypto/s2k.rs
index 8dff4693..40a26bda 100644
--- a/openpgp/src/crypto/s2k.rs
+++ b/openpgp/src/crypto/s2k.rs
@@ -416,7 +416,7 @@ mod tests {
 
             // Get the next packet.
             let (_, ppr) = pp.next().unwrap();
-            assert!(ppr.is_none());
+            assert!(ppr.is_err());
         }
     }
 
diff --git a/openpgp/src/packet/key.rs b/openpgp/src/packet/key.rs
index d06ac07e..29409ace 100644
--- a/openpgp/src/packet/key.rs
+++ b/openpgp/src/packet/key.rs
@@ -29,7 +29,7 @@
 //! ```rust
 //! # extern crate sequoia_openpgp as openpgp;
 //! # use openpgp::Result;
-//! # use openpgp::parse::{Parse, PacketParserResult, PacketParser};
+//! # use openpgp::parse::{Parse, PacketParser};
 //! # use openpgp::cert::prelude::*;
 //! use openpgp::packet::{Key, key};
 //!
diff --git a/openpgp/src/packet/signature/mod.rs b/openpgp/src/packet/signature/mod.rs
index 66c0065a..b294ae5a 100644
--- a/openpgp/src/packet/signature/mod.rs
+++ b/openpgp/src/packet/signature/mod.rs
@@ -1283,7 +1283,7 @@ mod test {
         use super::*;
 
         use crate::Cert;
-        use crate::parse::{PacketParserResult, PacketParser};
+        use crate::parse::PacketParser;
 
         struct Test<'a> {
             key: &'a str,
@@ -1369,7 +1369,7 @@ mod test {
             let mut good = 0;
             let mut ppr = PacketParser::from_bytes(
                 crate::tests::message(test.data)).unwrap();
-            while let PacketParserResult::Some(pp) = ppr {
+            while let Ok(pp) = ppr {
                 if let Packet::Signature(ref sig) = pp.packet {
                     let result = sig.verify(cert.primary_key().key())
                         .map(|_| true).unwrap_or(false);
diff --git a/openpgp/src/packet/signature/subpacket.rs b/openpgp/src/packet/signature/subpacket.rs
index 605d48d2..ac000842 100644
--- a/openpgp/src/packet/signature/subpacket.rs
+++ b/openpgp/src/packet/signature/subpacket.rs
@@ -34,13 +34,13 @@
 //! # extern crate sequoia_openpgp as openpgp;
 //! # use openpgp::Result;
 //! # use openpgp::Packet;
-//! # use openpgp::parse::{Parse, PacketParserResult, PacketParser};
+//! # use openpgp::parse::{Parse, PacketParser};
 //! #
 //! # f(include_bytes!("../../../tests/data/messages/signed.gpg"));
 //! #
 //! # fn f(message_data: &[u8]) -> Result<()> {
 //! let mut ppr = PacketParser::from_bytes(message_data)?;
-//! while let PacketParserResult::Some(mut pp) = ppr {
+//! while let Ok(mut pp) = ppr {
 //!     if let Packet::Signature(ref sig) = pp.packet {
 //!         if let Some(fp) = sig.issuer_fingerprint() {
 //!             eprintln!("Signature issued by: {}", fp.to_string());
diff --git a/openpgp/src/packet_pile.rs b/openpgp/src/packet_pile.rs
index 250d9f14..d3ced30f 100644
--- a/openpgp/src/packet_pile.rs
+++ b/openpgp/src/packet_pile.rs
@@ -349,7 +349,7 @@ impl<'a> TryFrom<PacketParserResult<'a>> for PacketPile {
         // ppo.recursion_depth and leave the rest of the message, but
         // it is hard to imagine that that is what the caller wants.
         // Instead of hiding that error, fail fast.
-        if let PacketParserResult::Some(ref pp) = ppr {
+        if let Ok(ref pp) = ppr {
             if pp.recursion_depth() != 0 {
                 return Err(Error::InvalidOperation(
                     format!("Expected top-level packet, \
@@ -363,7 +363,7 @@ impl<'a> TryFrom<PacketParserResult<'a>> for PacketPile {
 
         let mut last_position = 0;
 
-        if ppr.is_none() {
+        if ppr.is_err() {
             // Empty message.
             return Ok(PacketPile::from(Vec::new()));
         }
@@ -414,7 +414,7 @@ impl<'a> TryFrom<PacketParserResult<'a>> for PacketPile {
 
                 container.children_mut().unwrap().push(packet);
 
-                if ppr.is_none() {
+                if ppr.is_err() {
                     break 'outer;
                 }
 
@@ -561,7 +561,7 @@ mod test {
             .try_into().unwrap();
 
         let mut ppr = ppp.recurse().unwrap();
-        while ppr.is_some() {
+        while ppr.is_ok() {
             ppr = ppp.recurse().unwrap();
         }
         let pile = ppp.finish();
@@ -576,7 +576,7 @@ mod test {
             .try_into().unwrap();
 
         let mut ppr = ppp.recurse().unwrap();
-        while let Some(pp) = ppr.as_mut() {
+        while let Ok(pp) = ppr.as_mut() {
             eprintln!("{:?}", pp);
             ppr = ppp.recurse().unwrap();
         }
@@ -620,13 +620,13 @@ mod test {
 
         let mut count = 0;
         loop {
-            if let PacketParserResult::Some(pp2) = ppr {
+            if let Ok(pp2) = ppr {
                 count += 1;
 
                 let packet_depth = pp2.recursion_depth();
                 let pp2 = pp2.recurse().unwrap().1;
                 assert_eq!(packet_depth, count - 1);
-                if pp2.is_some() {
+                if pp2.is_ok() {
                     assert_eq!(pp2.as_ref().unwrap().recursion_depth(), count);
                 }
                 ppr = pp2;
@@ -664,7 +664,7 @@ mod test {
         // recurse should now not recurse.  Since there is nothing
         // following the compressed packet, ppr should be EOF.
         let (packet, ppr) = pp.next().unwrap();
-        assert!(ppr.is_none());
+        assert!(ppr.is_err());
 
         // Get the rest of the content and put the initial byte that
         // we stole back.
@@ -680,7 +680,7 @@ mod test {
 
         // And we're done...
         let ppr = pp.next().unwrap().1;
-        assert!(ppr.is_none());
+        assert!(ppr.is_err());
     }
 
     #[test]
diff --git a/openpgp/src/parse.rs b/openpgp/src/parse.rs
index c8c42a29..fb556ad2 100644
--- a/openpgp/src/parse.rs
+++ b/openpgp/src/parse.rs
@@ -212,13 +212,13 @@ macro_rules! impl_parse_generic_packet {
                 pp.buffer_unread_content()?;
 
                 match pp.next()? {
-                    (Packet::$typ(o), PacketParserResult::EOF(_))
+                    (Packet::$typ(o), Err(_))
                         => Ok(o),
-                    (p, PacketParserResult::EOF(_)) =>
+                    (p, Err(_)) =>
                         Err(Error::InvalidOperation(
                             format!("Not a {} packet: {:?}", stringify!($typ),
                                     p)).into()),
-                    (_, PacketParserResult::Some(_)) =>
+                    (_, Ok(_)) =>
                         Err(Error::InvalidOperation(
                             "Excess data after packet".into()).into()),
                 }
@@ -1821,7 +1821,7 @@ fn one_pass_sig_test () {
         let mut one_pass_sigs = 0;
         let mut sigs = 0;
 
-        while let PacketParserResult::Some(pp) = ppr {
+        while let Ok(pp) = ppr {
             if let Packet::OnePassSig(_) = pp.packet {
                 one_pass_sigs += 1;
             } else if let Packet::Signature(ref sig) = pp.packet {
@@ -2065,14 +2065,14 @@ impl<'a> Parse<'a, key::UnspecifiedKey> for key::UnspecifiedKey {
         pp.buffer_unread_content()?;
 
         match pp.next()? {
-            (Packet::PublicKey(o), PacketParserResult::EOF(_)) => Ok(o.into()),
-            (Packet::PublicSubkey(o), PacketParserResult::EOF(_)) => Ok(o.into()),
-            (Packet::SecretKey(o), PacketParserResult::EOF(_)) => Ok(o.into()),
-            (Packet::SecretSubkey(o), PacketParserResult::EOF(_)) => Ok(o.into()),
-            (p, PacketParserResult::EOF(_)) =>
+            (Packet::PublicKey(o), Err(_)) => Ok(o.into()),
+            (Packet::PublicSubkey(o), Err(_)) => Ok(o.into()),
+            (Packet::SecretKey(o), Err(_)) => Ok(o.into()),
+            (Packet::SecretSubkey(o), Err(_)) => Ok(o.into()),
+            (p, Err(_)) =>
                 Err(Error::InvalidOperation(
                     format!("Not a Key packet: {:?}", p)).into()),
-            (_, PacketParserResult::Some(_)) =>
+            (_, Ok(_)) =>
                 Err(Error::InvalidOperation(
                     "Excess data after packet".into()).into()),
         }
@@ -2331,7 +2331,7 @@ fn compressed_data_parser_test () {
         }
 
         // And, we're done...
-        assert!(ppr.is_none());
+        assert!(ppr.is_err());
     }
 }
 
@@ -2673,18 +2673,18 @@ impl<'a> Parse<'a, Packet> for Packet {
             ?.buffer_unread_content().build()?;
 
         let (p, ppr) = match ppr {
-            PacketParserResult::Some(pp) => {
+            Ok(pp) => {
                 pp.next()?
             },
-            PacketParserResult::EOF(_) =>
+            Err(_) =>
                 return Err(Error::InvalidOperation(
                     "Unexpected EOF".into()).into()),
         };
 
         match (p, ppr) {
-            (p, PacketParserResult::EOF(_)) =>
+            (p, Err(_)) =>
                 Ok(p),
-            (_, PacketParserResult::Some(_)) =>
+            (_, Ok(_)) =>
                 Err(Error::InvalidOperation(
                     "Excess data after packet".into()).into()),
         }
@@ -2754,12 +2754,12 @@ impl PacketParserState {
 /// # extern crate sequoia_openpgp as openpgp;
 /// # use openpgp::Result;
 /// # use openpgp::Packet;
-/// # use openpgp::parse::{Parse, PacketParserResult, PacketParser};
+/// # use openpgp::parse::{Parse, PacketParser};
 /// # let _ = f(include_bytes!("../tests/data/keys/public-key.gpg"));
 /// #
 /// # fn f(message_data: &[u8]) -> Result<()> {
 /// let mut ppr = PacketParser::from_bytes(message_data)?;
-/// while let PacketParserResult::Some(mut pp) = ppr {
+/// while let Ok(mut pp) = ppr {
 ///     // Process the packet.
 ///
 ///     if let Packet::Literal(_) = pp.packet {
@@ -2916,90 +2916,21 @@ impl PacketParserEOF {
 /// We don't use an `Option`, because when we reach the end of the
 /// packet sequence, some information about the message needs to
 /// remain accessible.
-#[derive(Debug)]
-pub enum PacketParserResult<'a> {
-    /// A `PacketParser` for the next packet.
-    Some(PacketParser<'a>),
-    /// Information about a fully parsed packet sequence.
-    EOF(PacketParserEOF),
-}
-
-impl<'a> PacketParserResult<'a> {
-    /// Like `Option::is_none`().
-    pub fn is_none(&self) -> bool {
-        if let PacketParserResult::EOF(_) = self {
-            true
-        } else {
-            false
-        }
-    }
-
-    /// An alias for `is_none`().
-    pub fn is_eof(&self) -> bool {
-        Self::is_none(self)
-    }
-
-    /// Like `Option::is_some`().
-    pub fn is_some(&self) -> bool {
-        ! Self::is_none(self)
-    }
-
-    /// Like `Option::expect`().
-    pub fn expect(self, msg: &str) -> PacketParser<'a> {
-        if let PacketParserResult::Some(pp) = self {
-            return pp;
-        } else {
-            panic!("{}", msg);
-        }
-    }
-
-    /// Like `Option::unwrap`().
-    pub fn unwrap(self) -> PacketParser<'a> {
-        self.expect("called `PacketParserResult::unwrap()` on a \
-                     `PacketParserResult::PacketParserEOF` value")
-    }
+pub type PacketParserResult<'a> =
+    std::result::Result<PacketParser<'a>, PacketParserEOF>;
 
-    /// Like `Option::as_ref`().
-    pub fn as_ref(&self) -> Option<