linting: Clear up bare trait object warnings

Newer Rust compilers requre `dyn` marking trait objects.

Signed-off-by: Daniel Silverstone <dsilvers@digital-scurf.org>

6 files changed, 39 insertions, 39 deletions

diff --git a/openpgp/src/parse/hashed_reader.rs b/openpgp/src/parse/hashed_reader.rs
index cbfc0330..ff1f77da 100644
--- a/openpgp/src/parse/hashed_reader.rs
+++ b/openpgp/src/parse/hashed_reader.rs
@@ -194,16 +194,16 @@ impl<R: BufferedReader<Cookie>>
         result
     }
 
-    fn get_mut(&mut self) -> Option<&mut BufferedReader<Cookie>> {
+    fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<Cookie>> {
         Some(&mut self.reader)
     }
 
-    fn get_ref(&self) -> Option<&BufferedReader<Cookie>> {
+    fn get_ref(&self) -> Option<&dyn BufferedReader<Cookie>> {
         Some(&self.reader)
     }
 
     fn into_inner<'b>(self: Box<Self>)
-            -> Option<Box<BufferedReader<Cookie> + 'b>>
+            -> Option<Box<dyn BufferedReader<Cookie> + 'b>>
             where Self: 'b {
         Some(Box::new(self.reader))
     }
diff --git a/openpgp/src/parse/packet_parser_builder.rs b/openpgp/src/parse/packet_parser_builder.rs
index 5719ddc4..b331801a 100644
--- a/openpgp/src/parse/packet_parser_builder.rs
+++ b/openpgp/src/parse/packet_parser_builder.rs
@@ -36,7 +36,7 @@ pub enum Dearmor {
 /// for instance, `PacketParser::from_file` or
 /// `PacketParser::from_reader` to start parsing an OpenPGP message.
 pub struct PacketParserBuilder<'a> {
-    bio: Box<'a + BufferedReader<Cookie>>,
+    bio: Box<dyn BufferedReader<Cookie> + 'a>,
     dearmor: Dearmor,
     settings: PacketParserSettings,
 }
@@ -72,7 +72,7 @@ impl<'a> PacketParserBuilder<'a> {
     //
     // Note: this clears the `level` field of the
     // `Cookie` cookie.
-    pub(crate) fn from_buffered_reader(mut bio: Box<'a + BufferedReader<Cookie>>)
+    pub(crate) fn from_buffered_reader(mut bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<Self> {
         bio.cookie_mut().level = None;
         Ok(PacketParserBuilder {
diff --git a/openpgp/src/parse/packet_pile_parser.rs b/openpgp/src/parse/packet_pile_parser.rs
index 815636df..9eca1b84 100644
--- a/openpgp/src/parse/packet_pile_parser.rs
+++ b/openpgp/src/parse/packet_pile_parser.rs
@@ -129,7 +129,7 @@ impl<'a> PacketPileParser<'a> {
 
     /// Creates a `PacketPileParser` to parse the OpenPGP message stored
     /// in the `BufferedReader` object.
-    pub(crate) fn from_buffered_reader(bio: Box<BufferedReader<Cookie> + 'a>)
+    pub(crate) fn from_buffered_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<PacketPileParser<'a>> {
         Self::from_packet_parser(PacketParser::from_buffered_reader(bio)?)
     }
diff --git a/openpgp/src/parse/parse.rs b/openpgp/src/parse/parse.rs
index ba00ce47..f79e2027 100644
--- a/openpgp/src/parse/parse.rs
+++ b/openpgp/src/parse/parse.rs
@@ -227,7 +227,7 @@ impl<'a> PacketHeaderParser<'a> {
     // Returns a `PacketHeaderParser` to parse an OpenPGP packet.
     // `inner` points to the start of the OpenPGP framing information,
     // i.e., the CTB.
-    fn new(inner: Box<'a + BufferedReader<Cookie>>,
+    fn new(inner: Box<dyn BufferedReader<Cookie> + 'a>,
            state: PacketParserState,
            path: Vec<usize>, header: Header,
            header_bytes: Vec<u8>) -> Self
@@ -256,7 +256,7 @@ impl<'a> PacketHeaderParser<'a> {
     // framing has already been processed, and `inner` already
     // includes any required filters (e.g., a
     // `BufferedReaderPartialBodyFilter`, etc.).
-    fn new_naked(inner: Box<'a + BufferedReader<Cookie>>) -> Self {
+    fn new_naked(inner: Box<dyn BufferedReader<Cookie> + 'a>) -> Self {
         PacketHeaderParser::new(inner,
                                 PacketParserState::new(Default::default()),
                                 vec![ 0 ],
@@ -600,9 +600,9 @@ impl Cookie {
     //
     // Thus to disable the hashing of a level 3 literal packet's
     // meta-data, we disable hashing at level 2.
-    fn hashing(reader: &mut BufferedReader<Cookie>,
+    fn hashing(reader: &mut dyn BufferedReader<Cookie>,
                how: Hashing, level: isize) {
-        let mut reader : Option<&mut BufferedReader<Cookie>>
+        let mut reader : Option<&mut dyn BufferedReader<Cookie>>
             = Some(reader);
         while let Some(r) = reader {
             {
@@ -626,9 +626,9 @@ impl Cookie {
     // A helpful debugging aid to pretty print a Buffered Reader
     // stack.
     #[allow(dead_code)]
-    fn dump(reader: &BufferedReader<Cookie>) {
+    fn dump(reader: &dyn BufferedReader<Cookie>) {
         let mut i = 1;
-        let mut reader : Option<&BufferedReader<Cookie>> = Some(reader);
+        let mut reader : Option<&dyn BufferedReader<Cookie>> = Some(reader);
         while let Some(r) = reader {
             {
                 let cookie = r.cookie_ref();
@@ -648,8 +648,8 @@ impl Cookie {
 
 // Pops readers from a buffered reader stack at the specified level.
 fn buffered_reader_stack_pop<'a>(
-    mut reader: Box<BufferedReader<Cookie> + 'a>, depth: isize)
-    -> Result<(bool, Box<BufferedReader<Cookie> + 'a>)>
+    mut reader: Box<dyn BufferedReader<Cookie> + 'a>, depth: isize)
+    -> Result<(bool, Box<dyn BufferedReader<Cookie> + 'a>)>
 {
     tracer!(TRACE, "buffered_reader_stack_pop", depth);
     t!("(reader level: {:?}, pop through: {})",
@@ -935,7 +935,7 @@ pub(crate) fn to_unknown_packet<R: Read>(reader: R) -> Result<Unknown>
         reader, None, Cookie::default());
     let header = Header::parse(&mut reader)?;
 
-    let reader : Box<BufferedReader<Cookie>>
+    let reader : Box<dyn BufferedReader<Cookie>>
         = match header.length() {
             &BodyLength::Full(len) =>
                 Box::new(buffered_reader::Limitor::with_cookie(
@@ -1202,7 +1202,7 @@ impl OnePassSig3 {
         // hashed reader on level recursion_depth - 1.
         let done = {
             let mut done = false;
-            let mut reader : Option<&mut BufferedReader<Cookie>>
+            let mut reader : Option<&mut dyn BufferedReader<Cookie>>
                 = Some(&mut php.reader);
             while let Some(r) = reader {
                 {
@@ -2015,7 +2015,7 @@ impl MDC {
 
         let mut computed_hash : [u8; 20] = Default::default();
         {
-            let mut r : Option<&mut BufferedReader<Cookie>>
+            let mut r : Option<&mut dyn BufferedReader<Cookie>>
                 = Some(&mut php.reader);
             while let Some(bio) = r {
                 {
@@ -2316,7 +2316,7 @@ pub struct PacketParser<'a> {
     // `next()` or `recurse()`.
     last_path: Vec<usize>,
 
-    reader: Box<BufferedReader<Cookie> + 'a>,
+    reader: Box<dyn BufferedReader<Cookie> + 'a>,
 
     // Whether the caller read the packet's content.  If so, then we
     // can't recurse, because we're missing some of the packet!
@@ -2358,7 +2358,7 @@ impl<'a> std::fmt::Debug for PacketParser<'a> {
 /// The return value of PacketParser::parse.
 enum ParserResult<'a> {
     Success(PacketParser<'a>),
-    EOF((Box<BufferedReader<Cookie> + 'a>, PacketParserState, Vec<usize>)),
+    EOF((Box<dyn BufferedReader<Cookie> + 'a>, PacketParserState, Vec<usize>)),
 }
 
 /// Information about the stream of packets parsed by the
@@ -2593,7 +2593,7 @@ impl <'a> PacketParser<'a> {
     ///
     /// This function returns a `PacketParser` for the first packet in
     /// the stream.
-    pub(crate) fn from_buffered_reader(bio: Box<BufferedReader<Cookie> + 'a>)
+    pub(crate) fn from_buffered_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>)
             -> Result<PacketParserResult<'a>> {
         PacketParserBuilder::from_buffered_reader(bio)?.finalize()
     }
@@ -2603,7 +2603,7 @@ impl <'a> PacketParser<'a> {
     ///
     /// This function may only be called when the `PacketParser` is in
     /// State::Body.
-    fn take_reader(&mut self) -> Box<BufferedReader<Cookie> + 'a> {
+    fn take_reader(&mut self) -> Box<dyn BufferedReader<Cookie> + 'a> {
         self.set_reader(
             Box::new(buffered_reader::EOF::with_cookie(Default::default())))
     }
@@ -2612,14 +2612,14 @@ impl <'a> PacketParser<'a> {
     ///
     /// This function may only be called when the `PacketParser` is in
     /// State::Body.
-    fn set_reader(&mut self, reader: Box<BufferedReader<Cookie> + 'a>)
-        -> Box<BufferedReader<Cookie> + 'a>
+    fn set_reader(&mut self, reader: Box<dyn BufferedReader<Cookie> + 'a>)
+        -> Box<dyn BufferedReader<Cookie> + 'a>
     {
         mem::replace(&mut self.reader, reader)
     }
 
     /// Returns a mutable reference to the reader stack.
-    fn mut_reader(&mut self) -> &mut BufferedReader<Cookie> {
+    fn mut_reader(&mut self) -> &mut dyn BufferedReader<Cookie> {
         &mut self.reader
     }
 
@@ -2773,7 +2773,7 @@ impl <'a> PacketParser<'a> {
     /// Returns a `PacketParser` for the next OpenPGP packet in the
     /// stream.  If there are no packets left, this function returns
     /// `bio`.
-    fn parse(mut bio: Box<BufferedReader<Cookie> + 'a>,
+    fn parse(mut bio: Box<dyn BufferedReader<Cookie> + 'a>,
              state: PacketParserState,
              path: Vec<usize>)
         -> Result<ParserResult<'a>>
@@ -2883,7 +2883,7 @@ impl <'a> PacketParser<'a> {
         let header_bytes =
             Vec::from(&bio.data_consume_hard(consumed)?[..consumed]);
 
-        let bio : Box<BufferedReader<Cookie>>
+        let bio : Box<dyn BufferedReader<Cookie>>
             = match header.length() {
                 &BodyLength::Full(len) => {
                     t!("Pushing a limitor ({} bytes), level: {}.",
@@ -3416,16 +3416,16 @@ impl<'a> BufferedReader<Cookie> for PacketParser<'a> {
         self.reader.drop_eof()
     }
 
-    fn get_mut(&mut self) -> Option<&mut BufferedReader<Cookie>> {
+    fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<Cookie>> {
         None
     }
 
-    fn get_ref(&self) -> Option<&BufferedReader<Cookie>> {
+    fn get_ref(&self) -> Option<&dyn BufferedReader<Cookie>> {
         None
     }
 
     fn into_inner<'b>(self: Box<Self>)
-            -> Option<Box<BufferedReader<Cookie> + 'b>>
+            -> Option<Box<dyn BufferedReader<Cookie> + 'b>>
             where Self: 'b {
         None
     }
diff --git a/openpgp/src/parse/partial_body.rs b/openpgp/src/parse/partial_body.rs
index 13b3f6b9..bc4e6309 100644
--- a/openpgp/src/parse/partial_body.rs
+++ b/openpgp/src/parse/partial_body.rs
@@ -375,15 +375,15 @@ impl<T: BufferedReader<Cookie>> BufferedReader<Cookie>
         self.partial_body_length == 0 && self.last
     }
 
-    fn get_mut(&mut self) -> Option<&mut BufferedReader<Cookie>> {
+    fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<Cookie>> {
         Some(&mut self.reader)
     }
 
-    fn get_ref(&self) -> Option<&BufferedReader<Cookie>> {
+    fn get_ref(&self) -> Option<&dyn BufferedReader<Cookie>> {
         Some(&self.reader)
     }
 
-    fn into_inner<'b>(self: Box<Self>) -> Option<Box<BufferedReader<Cookie> + 'b>>
+    fn into_inner<'b>(self: Box<Self>) -> Option<Box<dyn BufferedReader<Cookie> + 'b>>
             where Self: 'b {
         Some(Box::new(self.reader))
     }
diff --git a/openpgp/src/parse/stream.rs b/openpgp/src/parse/stream.rs
index 4a97134b..c2e477cd 100644
--- a/openpgp/src/parse/stream.rs
+++ b/openpgp/src/parse/stream.rs
@@ -468,7 +468,7 @@ impl<'a, H: VerificationHelper> Verifier<'a, H> {
     ///
     /// Signature verifications are done relative to time `t`, or the
     /// current time, if `t` is `None`.
-    pub(crate) fn from_buffered_reader(bio: Box<BufferedReader<Cookie> + 'a>,
+    pub(crate) fn from_buffered_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>,
                                        helper: H, t: time::Tm)
                                        -> Result<Verifier<'a, H>>
     {
@@ -717,7 +717,7 @@ impl<'a, H: VerificationHelper> io::Read for Verifier<'a, H> {
 struct Transformer<'a> {
     state: TransformationState,
     sigs: Vec<Signature>,
-    reader: Box<'a + BufferedReader<()>>,
+    reader: Box<dyn BufferedReader<()> + 'a>,
     buffer: Vec<u8>,
 }
 
@@ -729,8 +729,8 @@ enum TransformationState {
 }
 
 impl<'a> Transformer<'a> {
-    fn new<'b>(signatures: Box<'b + BufferedReader<Cookie>>,
-               mut data: Box<'a + BufferedReader<()>>)
+    fn new<'b>(signatures: Box<dyn BufferedReader<Cookie> + 'b>,
+               mut data: Box<dyn BufferedReader<()> + 'a>)
                -> Result<Transformer<'a>>
     {
         let mut sigs = Vec::new();
@@ -1009,8 +1009,8 @@ impl DetachedVerifier {
     /// Signature verifications are done relative to time `t`, or the
     /// current time, if `t` is `None`.
     pub(crate) fn from_buffered_reader<'a, 's, H>
-        (signature_bio: Box<BufferedReader<Cookie> + 's>,
-         reader: Box<'a + BufferedReader<()>>,
+        (signature_bio: Box<dyn BufferedReader<Cookie> + 's>,
+         reader: Box<dyn BufferedReader<()> + 'a>,
          helper: H, t: time::Tm)
          -> Result<Verifier<'a, H>>
         where H: VerificationHelper
@@ -1212,7 +1212,7 @@ impl<'a, H: VerificationHelper + DecryptionHelper> Decryptor<'a, H> {
     }
 
     /// Creates the `Decryptor`, and buffers the data up to `BUFFER_SIZE`.
-    pub(crate) fn from_buffered_reader(bio: Box<BufferedReader<Cookie> + 'a>,
+    pub(crate) fn from_buffered_reader(bio: Box<dyn BufferedReader<Cookie> + 'a>,
                                        helper: H, t: time::Tm)
                                        -> Result<Decryptor<'a, H>>
     {