Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 76 insertions, 19 deletions

diff --git a/vendor/serde_json/src/de.rs b/vendor/serde_json/src/de.rs
index 88d0f2624..4b16ba2a8 100644
--- a/vendor/serde_json/src/de.rs
+++ b/vendor/serde_json/src/de.rs
@@ -2408,9 +2408,9 @@ where
     Ok(value)
 }
 
-/// Deserialize an instance of type `T` from an IO stream of JSON.
+/// Deserialize an instance of type `T` from an I/O stream of JSON.
 ///
-/// The content of the IO stream is deserialized directly from the stream
+/// The content of the I/O stream is deserialized directly from the stream
 /// without being buffered in memory by serde_json.
 ///
 /// When reading from a source against which short reads are not efficient, such
diff --git a/vendor/serde_json/src/error.rs b/vendor/serde_json/src/error.rs
index 0898baf90..7ba3a4edd 100644
--- a/vendor/serde_json/src/error.rs
+++ b/vendor/serde_json/src/error.rs
@@ -9,6 +9,8 @@ use core::str::FromStr;
 use serde::{de, ser};
 #[cfg(feature = "std")]
 use std::error;
+#[cfg(feature = "std")]
+use std::io::ErrorKind;
 
 /// This type represents all possible errors that can occur when serializing or
 /// deserializing JSON data.
@@ -36,15 +38,16 @@ impl Error {
     /// The first character in the input and any characters immediately
     /// following a newline character are in column 1.
     ///
-    /// Note that errors may occur in column 0, for example if a read from an IO
-    /// stream fails immediately following a previously read newline character.
+    /// Note that errors may occur in column 0, for example if a read from an
+    /// I/O stream fails immediately following a previously read newline
+    /// character.
     pub fn column(&self) -> usize {
         self.err.column
     }
 
     /// Categorizes the cause of this error.
     ///
-    /// - `Category::Io` - failure to read or write bytes on an IO stream
+    /// - `Category::Io` - failure to read or write bytes on an I/O stream
     /// - `Category::Syntax` - input that is not syntactically valid JSON
     /// - `Category::Data` - input data that is semantically incorrect
     /// - `Category::Eof` - unexpected end of the input data
@@ -76,7 +79,7 @@ impl Error {
     }
 
     /// Returns true if this error was caused by a failure to read or write
-    /// bytes on an IO stream.
+    /// bytes on an I/O stream.
     pub fn is_io(&self) -> bool {
         self.classify() == Category::Io
     }
@@ -104,12 +107,61 @@ impl Error {
     pub fn is_eof(&self) -> bool {
         self.classify() == Category::Eof
     }
+
+    /// The kind reported by the underlying standard library I/O error, if this
+    /// error was caused by a failure to read or write bytes on an I/O stream.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use serde_json::Value;
+    /// use std::io::{self, ErrorKind, Read};
+    /// use std::process;
+    ///
+    /// struct ReaderThatWillTimeOut<'a>(&'a [u8]);
+    ///
+    /// impl<'a> Read for ReaderThatWillTimeOut<'a> {
+    ///     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    ///         if self.0.is_empty() {
+    ///             Err(io::Error::new(ErrorKind::TimedOut, "timed out"))
+    ///         } else {
+    ///             self.0.read(buf)
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// fn main() {
+    ///     let reader = ReaderThatWillTimeOut(br#" {"k": "#);
+    ///
+    ///     let _: Value = match serde_json::from_reader(reader) {
+    ///         Ok(value) => value,
+    ///         Err(error) => {
+    ///             if error.io_error_kind() == Some(ErrorKind::TimedOut) {
+    ///                 // Maybe this application needs to retry certain kinds of errors.
+    ///
+    ///                 # return;
+    ///             } else {
+    ///                 eprintln!("error: {}", error);
+    ///                 process::exit(1);
+    ///             }
+    ///         }
+    ///     };
+    /// }
+    /// ```
+    #[cfg(feature = "std")]
+    pub fn io_error_kind(&self) -> Option<ErrorKind> {
+        if let ErrorCode::Io(io_error) = &self.err.code {
+            Some(io_error.kind())
+        } else {
+            None
+        }
+    }
 }
 
 /// Categorizes the cause of a `serde_json::Error`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum Category {
-    /// The error was caused by a failure to read or write bytes on an IO
+    /// The error was caused by a failure to read or write bytes on an I/O
     /// stream.
     Io,
 
@@ -134,8 +186,8 @@ pub enum Category {
 impl From<Error> for io::Error {
     /// Convert a `serde_json::Error` into an `io::Error`.
     ///
-    /// JSON syntax and data errors are turned into `InvalidData` IO errors.
-    /// EOF errors are turned into `UnexpectedEof` IO errors.
+    /// JSON syntax and data errors are turned into `InvalidData` I/O errors.
+    /// EOF errors are turned into `UnexpectedEof` I/O errors.
     ///
     /// ```
     /// use std::io;
@@ -165,8 +217,8 @@ impl From<Error> for io::Error {
         } else {
             match j.classify() {
                 Category::Io => unreachable!(),
-                Category::Syntax | Category::Data => io::Error::new(io::ErrorKind::InvalidData, j),
-                Category::Eof => io::Error::new(io::ErrorKind::UnexpectedEof, j),
+                Category::Syntax | Category::Data => io::Error::new(ErrorKind::InvalidData, j),
+                Category::Eof => io::Error::new(ErrorKind::UnexpectedEof, j),
             }
         }
     }
@@ -182,7 +234,7 @@ pub(crate) enum ErrorCode {
     /// Catchall for syntax error messages
     Message(Box<str>),
 
-    /// Some IO error occurred while serializing or deserializing.
+    /// Some I/O error occurred while serializing or deserializing.
     Io(io::Error),
 
     /// EOF while parsing a list.
diff --git a/vendor/serde_json/src/io/core.rs b/vendor/serde_json/src/io/core.rs
index 465ab8b24..54c8ddfda 100644
--- a/vendor/serde_json/src/io/core.rs
+++ b/vendor/serde_json/src/io/core.rs
@@ -9,7 +9,7 @@ pub enum ErrorKind {
     Other,
 }
 
-// IO errors can never occur in no-std mode. All our no-std IO implementations
+// I/O errors can never occur in no-std mode. All our no-std I/O implementations
 // are infallible.
 pub struct Error;
 
diff --git a/vendor/serde_json/src/lib.rs b/vendor/serde_json/src/lib.rs
index 95242d40b..227a87bd8 100644
--- a/vendor/serde_json/src/lib.rs
+++ b/vendor/serde_json/src/lib.rs
@@ -300,7 +300,7 @@
 //! [macro]: crate::json
 //! [`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-core
 
-#![doc(html_root_url = "https://docs.rs/serde_json/1.0.95")]
+#![doc(html_root_url = "https://docs.rs/serde_json/1.0.99")]
 // Ignored clippy lints
 #![allow(
     clippy::collapsible_else_if,
diff --git a/vendor/serde_json/src/macros.rs b/vendor/serde_json/src/macros.rs
index 5287998b4..e8c6cd2ca 100644
--- a/vendor/serde_json/src/macros.rs
+++ b/vendor/serde_json/src/macros.rs
@@ -10,7 +10,8 @@
 ///         "features": [
 ///             "serde",
 ///             "json"
-///         ]
+///         ],
+///         "homepage": null
 ///     }
 /// });
 /// ```
diff --git a/vendor/serde_json/src/ser.rs b/vendor/serde_json/src/ser.rs
index 80c2deb0c..820825d37 100644
--- a/vendor/serde_json/src/ser.rs
+++ b/vendor/serde_json/src/ser.rs
@@ -1043,11 +1043,11 @@ where
         Err(key_must_be_a_string())
     }
 
-    fn serialize_some<T>(self, _value: &T) -> Result<()>
+    fn serialize_some<T>(self, value: &T) -> Result<()>
     where
         T: ?Sized + Serialize,
     {
-        Err(key_must_be_a_string())
+        value.serialize(self)
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
@@ -2062,7 +2062,9 @@ static ESCAPE: [u8; 256] = [
     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
 ];
 
-/// Serialize the given data structure as JSON into the IO stream.
+/// Serialize the given data structure as JSON into the I/O stream.
+///
+/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
 ///
 /// # Errors
 ///
@@ -2079,9 +2081,11 @@ where
     value.serialize(&mut ser)
 }
 
-/// Serialize the given data structure as pretty-printed JSON into the IO
+/// Serialize the given data structure as pretty-printed JSON into the I/O
 /// stream.
 ///
+/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
+///
 /// # Errors
 ///
 /// Serialization can fail if `T`'s implementation of `Serialize` decides to