Adding upstream version 110.0.1.upstream/110.0.1upstream

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

13 files changed, 5846 insertions, 0 deletions

diff --git a/third_party/rust/serde_yaml/src/de.rs b/third_party/rust/serde_yaml/src/de.rs
new file mode 100644
index 0000000000..8ccf271093
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/de.rs
@@ -0,0 +1,1525 @@
+use crate::error::{self, Error, ErrorImpl, Result};
+use crate::path::Path;
+use serde::de::{
+    self, Deserialize, DeserializeOwned, DeserializeSeed, Expected, IgnoredAny as Ignore,
+    IntoDeserializer, Unexpected, Visitor,
+};
+use std::collections::BTreeMap;
+use std::f64;
+use std::fmt;
+use std::io;
+use std::marker::PhantomData;
+use std::mem;
+use std::str;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use yaml_rust::parser::{Event as YamlEvent, MarkedEventReceiver, Parser};
+use yaml_rust::scanner::{Marker, TScalarStyle, TokenType};
+
+/// A structure that deserializes YAML into Rust values.
+///
+/// # Examples
+///
+/// Deserializing a single document:
+///
+/// ```
+/// use anyhow::Result;
+/// use serde::Deserialize;
+/// use serde_yaml::Value;
+///
+/// fn main() -> Result<()> {
+///     let input = "---\nk: 107\n";
+///     let de = serde_yaml::Deserializer::from_str(input);
+///     let value = Value::deserialize(de)?;
+///     println!("{:?}", value);
+///     Ok(())
+/// }
+/// ```
+///
+/// Deserializing multi-doc YAML:
+///
+/// ```
+/// use anyhow::Result;
+/// use serde::Deserialize;
+/// use serde_yaml::Value;
+///
+/// fn main() -> Result<()> {
+///     let input = "---\nk: 107\n...\n---\nj: 106\n";
+///
+///     for document in serde_yaml::Deserializer::from_str(input) {
+///         let value = Value::deserialize(document)?;
+///         println!("{:?}", value);
+///     }
+///
+///     Ok(())
+/// }
+/// ```
+pub struct Deserializer<'a> {
+    input: Input<'a>,
+}
+
+enum Input<'a> {
+    Str(&'a str),
+    Slice(&'a [u8]),
+    Read(Box<dyn io::Read + 'a>),
+    Multidoc(Arc<Multidoc>),
+    Fail(Arc<ErrorImpl>),
+}
+
+impl<'a> Deserializer<'a> {
+    /// Creates a YAML deserializer from a `&str`.
+    pub fn from_str(s: &'a str) -> Self {
+        let input = Input::Str(s);
+        Deserializer { input }
+    }
+
+    /// Creates a YAML deserializer from a `&[u8]`.
+    pub fn from_slice(v: &'a [u8]) -> Self {
+        let input = Input::Slice(v);
+        Deserializer { input }
+    }
+
+    /// Creates a YAML deserializer from an `io::Read`.
+    ///
+    /// Reader-based deserializers do not support deserializing borrowed types
+    /// like `&str`, since the `std::io::Read` trait has no non-copying methods
+    /// -- everything it does involves copying bytes out of the data source.
+    pub fn from_reader<R>(rdr: R) -> Self
+    where
+        R: io::Read + 'a,
+    {
+        let input = Input::Read(Box::new(rdr));
+        Deserializer { input }
+    }
+
+    fn de<T>(self, f: impl FnOnce(&mut DeserializerFromEvents) -> Result<T>) -> Result<T> {
+        if let Input::Multidoc(multidoc) = &self.input {
+            let mut pos = multidoc.pos.load(Ordering::Relaxed);
+            let t = f(&mut DeserializerFromEvents {
+                events: &multidoc.loader.events,
+                aliases: &multidoc.loader.aliases,
+                pos: &mut pos,
+                path: Path::Root,
+                remaining_depth: 128,
+            })?;
+            multidoc.pos.store(pos, Ordering::Relaxed);
+            return Ok(t);
+        }
+
+        let loader = loader(self.input)?;
+        if loader.events.is_empty() {
+            return Err(error::end_of_stream());
+        }
+        let mut pos = 0;
+        let t = f(&mut DeserializerFromEvents {
+            events: &loader.events,
+            aliases: &loader.aliases,
+            pos: &mut pos,
+            path: Path::Root,
+            remaining_depth: 128,
+        })?;
+        if pos == loader.events.len() {
+            Ok(t)
+        } else {
+            Err(error::more_than_one_document())
+        }
+    }
+}
+
+fn loader(input: Input) -> Result<Loader> {
+    enum Input2<'a> {
+        Str(&'a str),
+        Slice(&'a [u8]),
+    }
+
+    let mut buffer;
+    let input = match input {
+        Input::Str(s) => Input2::Str(s),
+        Input::Slice(bytes) => Input2::Slice(bytes),
+        Input::Read(mut rdr) => {
+            buffer = Vec::new();
+            rdr.read_to_end(&mut buffer).map_err(error::io)?;
+            Input2::Slice(&buffer)
+        }
+        Input::Multidoc(_) => unreachable!(),
+        Input::Fail(err) => return Err(error::shared(err)),
+    };
+
+    let input = match input {
+        Input2::Str(s) => s,
+        Input2::Slice(bytes) => str::from_utf8(bytes).map_err(error::str_utf8)?,
+    };
+
+    let mut parser = Parser::new(input.chars());
+    let mut loader = Loader {
+        events: Vec::new(),
+        aliases: BTreeMap::new(),
+    };
+    parser.load(&mut loader, true).map_err(error::scanner)?;
+    Ok(loader)
+}
+
+struct Multidoc {
+    loader: Loader,
+    pos: AtomicUsize,
+}
+
+impl<'de> Iterator for Deserializer<'de> {
+    type Item = Self;
+
+    fn next(&mut self) -> Option<Self> {
+        match &self.input {
+            Input::Multidoc(multidoc) => {
+                let pos = multidoc.pos.load(Ordering::Relaxed);
+                return if pos < multidoc.loader.events.len() {
+                    Some(Deserializer {
+                        input: Input::Multidoc(Arc::clone(multidoc)),
+                    })
+                } else {
+                    None
+                };
+            }
+            Input::Fail(err) => {
+                return Some(Deserializer {
+                    input: Input::Fail(Arc::clone(err)),
+                });
+            }
+            _ => {}
+        }
+
+        let dummy = Input::Str("");
+        let input = mem::replace(&mut self.input, dummy);
+        match loader(input) {
+            Ok(loader) => {
+                let multidoc = Arc::new(Multidoc {
+                    loader,
+                    pos: AtomicUsize::new(0),
+                });
+                self.input = Input::Multidoc(Arc::clone(&multidoc));
+                if multidoc.loader.events.is_empty() {
+                    None
+                } else {
+                    Some(Deserializer {
+                        input: Input::Multidoc(multidoc),
+                    })
+                }
+            }
+            Err(err) => {
+                let fail = err.shared();
+                self.input = Input::Fail(Arc::clone(&fail));
+                Some(Deserializer {
+                    input: Input::Fail(fail),
+                })
+            }
+        }
+    }
+}
+
+impl<'de> de::Deserializer<'de> for Deserializer<'de> {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_any(visitor))
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_bool(visitor))
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_i8(visitor))
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_i16(visitor))
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_i32(visitor))
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_i64(visitor))
+    }
+
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_i128(visitor))
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_u8(visitor))
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_u16(visitor))
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_u32(visitor))
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_u64(visitor))
+    }
+
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_u128(visitor))
+    }
+
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_f32(visitor))
+    }
+
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_f64(visitor))
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_char(visitor))
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_str(visitor))
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_string(visitor))
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_bytes(visitor))
+    }
+
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_byte_buf(visitor))
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_option(visitor))
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_unit(visitor))
+    }
+
+    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_unit_struct(name, visitor))
+    }
+
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_newtype_struct(name, visitor))
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_seq(visitor))
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_tuple(len, visitor))
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        name: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_tuple_struct(name, len, visitor))
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_map(visitor))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_struct(name, fields, visitor))
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_enum(name, variants, visitor))
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_identifier(visitor))
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de(|state| state.deserialize_ignored_any(visitor))
+    }
+}
+
+pub struct Loader {
+    events: Vec<(Event, Marker)>,
+    /// Map from alias id to index in events.
+    aliases: BTreeMap<usize, usize>,
+}
+
+impl MarkedEventReceiver for Loader {
+    fn on_event(&mut self, event: YamlEvent, marker: Marker) {
+        let event = match event {
+            YamlEvent::Nothing
+            | YamlEvent::StreamStart
+            | YamlEvent::StreamEnd
+            | YamlEvent::DocumentStart
+            | YamlEvent::DocumentEnd => return,
+
+            YamlEvent::Alias(id) => Event::Alias(id),
+            YamlEvent::Scalar(value, style, id, tag) => {
+                self.aliases.insert(id, self.events.len());
+                Event::Scalar(value, style, tag)
+            }
+            YamlEvent::SequenceStart(id) => {
+                self.aliases.insert(id, self.events.len());
+                Event::SequenceStart
+            }
+            YamlEvent::SequenceEnd => Event::SequenceEnd,
+            YamlEvent::MappingStart(id) => {
+                self.aliases.insert(id, self.events.len());
+                Event::MappingStart
+            }
+            YamlEvent::MappingEnd => Event::MappingEnd,
+        };
+        self.events.push((event, marker));
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum Event {
+    Alias(usize),
+    Scalar(String, TScalarStyle, Option<TokenType>),
+    SequenceStart,
+    SequenceEnd,
+    MappingStart,
+    MappingEnd,
+}
+
+struct DeserializerFromEvents<'a> {
+    events: &'a [(Event, Marker)],
+    /// Map from alias id to index in events.
+    aliases: &'a BTreeMap<usize, usize>,
+    pos: &'a mut usize,
+    path: Path<'a>,
+    remaining_depth: u8,
+}
+
+impl<'a> DeserializerFromEvents<'a> {
+    fn peek(&self) -> Result<(&'a Event, Marker)> {
+        match self.events.get(*self.pos) {
+            Some(event) => Ok((&event.0, event.1)),
+            None => Err(error::end_of_stream()),
+        }
+    }
+
+    fn next(&mut self) -> Result<(&'a Event, Marker)> {
+        self.opt_next().ok_or_else(error::end_of_stream)
+    }
+
+    fn opt_next(&mut self) -> Option<(&'a Event, Marker)> {
+        self.events.get(*self.pos).map(|event| {
+            *self.pos += 1;
+            (&event.0, event.1)
+        })
+    }
+
+    fn jump(&'a self, pos: &'a mut usize) -> Result<DeserializerFromEvents<'a>> {
+        match self.aliases.get(pos) {
+            Some(&found) => {
+                *pos = found;
+                Ok(DeserializerFromEvents {
+                    events: self.events,
+                    aliases: self.aliases,
+                    pos,
+                    path: Path::Alias { parent: &self.path },
+                    remaining_depth: self.remaining_depth,
+                })
+            }
+            None => panic!("unresolved alias: {}", *pos),
+        }
+    }
+
+    fn ignore_any(&mut self) {
+        enum Nest {
+            Sequence,
+            Mapping,
+        }
+
+        let mut stack = Vec::new();
+
+        while let Some((event, _)) = self.opt_next() {
+            match event {
+                Event::Alias(_) | Event::Scalar(_, _, _) => {}
+                Event::SequenceStart => {
+                    stack.push(Nest::Sequence);
+                }
+                Event::MappingStart => {
+                    stack.push(Nest::Mapping);
+                }
+                Event::SequenceEnd => match stack.pop() {
+                    Some(Nest::Sequence) => {}
+                    None | Some(Nest::Mapping) => {
+                        panic!("unexpected end of sequence");
+                    }
+                },
+                Event::MappingEnd => match stack.pop() {
+                    Some(Nest::Mapping) => {}
+                    None | Some(Nest::Sequence) => {
+                        panic!("unexpected end of mapping");
+                    }
+                },
+            }
+            if stack.is_empty() {
+                return;
+            }
+        }
+
+        if !stack.is_empty() {
+            panic!("missing end event");
+        }
+    }
+
+    fn visit_sequence<'de, V>(&mut self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (value, len) = self.recursion_check(|de| {
+            let mut seq = SeqAccess { de, len: 0 };
+            let value = visitor.visit_seq(&mut seq)?;
+            Ok((value, seq.len))
+        })?;
+        self.end_sequence(len)?;
+        Ok(value)
+    }
+
+    fn visit_mapping<'de, V>(&mut self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (value, len) = self.recursion_check(|de| {
+            let mut map = MapAccess {
+                de,
+                len: 0,
+                key: None,
+            };
+            let value = visitor.visit_map(&mut map)?;
+            Ok((value, map.len))
+        })?;
+        self.end_mapping(len)?;
+        Ok(value)
+    }
+
+    fn end_sequence(&mut self, len: usize) -> Result<()> {
+        let total = {
+            let mut seq = SeqAccess { de: self, len };
+            while de::SeqAccess::next_element::<Ignore>(&mut seq)?.is_some() {}
+            seq.len
+        };
+        assert_eq!(Event::SequenceEnd, *self.next()?.0);
+        if total == len {
+            Ok(())
+        } else {
+            struct ExpectedSeq(usize);
+            impl Expected for ExpectedSeq {
+                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    if self.0 == 1 {
+                        write!(formatter, "sequence of 1 element")
+                    } else {
+                        write!(formatter, "sequence of {} elements", self.0)
+                    }
+                }
+            }
+            Err(de::Error::invalid_length(total, &ExpectedSeq(len)))
+        }
+    }
+
+    fn end_mapping(&mut self, len: usize) -> Result<()> {
+        let total = {
+            let mut map = MapAccess {
+                de: self,
+                len,
+                key: None,
+            };
+            while de::MapAccess::next_entry::<Ignore, Ignore>(&mut map)?.is_some() {}
+            map.len
+        };
+        assert_eq!(Event::MappingEnd, *self.next()?.0);
+        if total == len {
+            Ok(())
+        } else {
+            struct ExpectedMap(usize);
+            impl Expected for ExpectedMap {
+                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    if self.0 == 1 {
+                        write!(formatter, "map containing 1 entry")
+                    } else {
+                        write!(formatter, "map containing {} entries", self.0)
+                    }
+                }
+            }
+            Err(de::Error::invalid_length(total, &ExpectedMap(len)))
+        }
+    }
+
+    fn recursion_check<F: FnOnce(&mut Self) -> Result<T>, T>(&mut self, f: F) -> Result<T> {
+        let previous_depth = self.remaining_depth;
+        self.remaining_depth = previous_depth
+            .checked_sub(1)
+            .ok_or_else(error::recursion_limit_exceeded)?;
+        let result = f(self);
+        self.remaining_depth = previous_depth;
+        result
+    }
+}
+
+fn visit_scalar<'de, V>(
+    v: &str,
+    style: TScalarStyle,
+    tag: &Option<TokenType>,
+    visitor: V,
+) -> Result<V::Value>
+where
+    V: Visitor<'de>,
+{
+    if let Some(TokenType::Tag(handle, suffix)) = tag {
+        if handle == "!!" {
+            match suffix.as_ref() {
+                "bool" => match v.parse::<bool>() {
+                    Ok(v) => visitor.visit_bool(v),
+                    Err(_) => Err(de::Error::invalid_value(Unexpected::Str(v), &"a boolean")),
+                },
+                "int" => match v.parse::<i64>() {
+                    Ok(v) => visitor.visit_i64(v),
+                    Err(_) => Err(de::Error::invalid_value(Unexpected::Str(v), &"an integer")),
+                },
+                "float" => match v.parse::<f64>() {
+                    Ok(v) => visitor.visit_f64(v),
+                    Err(_) => Err(de::Error::invalid_value(Unexpected::Str(v), &"a float")),
+                },
+                "null" => match v {
+                    "~" | "null" => visitor.visit_unit(),
+                    _ => Err(de::Error::invalid_value(Unexpected::Str(v), &"null")),
+                },
+                _ => visitor.visit_str(v),
+            }
+        } else {
+            visitor.visit_str(v)
+        }
+    } else if style == TScalarStyle::Plain {
+        visit_untagged_str(visitor, v)
+    } else {
+        visitor.visit_str(v)
+    }
+}
+
+struct SeqAccess<'a: 'r, 'r> {
+    de: &'r mut DeserializerFromEvents<'a>,
+    len: usize,
+}
+
+impl<'de, 'a, 'r> de::SeqAccess<'de> for SeqAccess<'a, 'r> {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.de.peek()?.0 {
+            Event::SequenceEnd => Ok(None),
+            _ => {
+                let mut element_de = DeserializerFromEvents {
+                    events: self.de.events,
+                    aliases: self.de.aliases,
+                    pos: self.de.pos,
+                    path: Path::Seq {
+                        parent: &self.de.path,
+                        index: self.len,
+                    },
+                    remaining_depth: self.de.remaining_depth,
+                };
+                self.len += 1;
+                seed.deserialize(&mut element_de).map(Some)
+            }
+        }
+    }
+}
+
+struct MapAccess<'a: 'r, 'r> {
+    de: &'r mut DeserializerFromEvents<'a>,
+    len: usize,
+    key: Option<&'a str>,
+}
+
+impl<'de, 'a, 'r> de::MapAccess<'de> for MapAccess<'a, 'r> {
+    type Error = Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+    where
+        K: DeserializeSeed<'de>,
+    {
+        match self.de.peek()?.0 {
+            Event::MappingEnd => Ok(None),
+            Event::Scalar(key, _, _) => {
+                self.len += 1;
+                self.key = Some(key);
+                seed.deserialize(&mut *self.de).map(Some)
+            }
+            _ => {
+                self.len += 1;
+                self.key = None;
+                seed.deserialize(&mut *self.de).map(Some)
+            }
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        let mut value_de = DeserializerFromEvents {
+            events: self.de.events,
+            aliases: self.de.aliases,
+            pos: self.de.pos,
+            path: if let Some(key) = self.key {
+                Path::Map {
+                    parent: &self.de.path,
+                    key,
+                }
+            } else {
+                Path::Unknown {
+                    parent: &self.de.path,
+                }
+            },
+            remaining_depth: self.de.remaining_depth,
+        };
+        seed.deserialize(&mut value_de)
+    }
+}
+
+struct EnumAccess<'a: 'r, 'r> {
+    de: &'r mut DeserializerFromEvents<'a>,
+    name: &'static str,
+    tag: Option<&'static str>,
+}
+
+impl<'de, 'a, 'r> de::EnumAccess<'de> for EnumAccess<'a, 'r> {
+    type Error = Error;
+    type Variant = DeserializerFromEvents<'r>;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        #[derive(Debug)]
+        enum Nope {}
+
+        struct BadKey {
+            name: &'static str,
+        }
+
+        impl<'de> Visitor<'de> for BadKey {
+            type Value = Nope;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                write!(formatter, "variant of enum `{}`", self.name)
+            }
+        }
+
+        let variant = if let Some(tag) = self.tag {
+            tag
+        } else {
+            match self.de.next()?.0 {
+                Event::Scalar(s, _, _) => &**s,
+                _ => {
+                    *self.de.pos -= 1;
+                    let bad = BadKey { name: self.name };
+                    return Err(de::Deserializer::deserialize_any(&mut *self.de, bad).unwrap_err());
+                }
+            }
+        };
+
+        let str_de = IntoDeserializer::<Error>::into_deserializer(variant);
+        let ret = seed.deserialize(str_de)?;
+        let variant_visitor = DeserializerFromEvents {
+            events: self.de.events,
+            aliases: self.de.aliases,
+            pos: self.de.pos,
+            path: Path::Map {
+                parent: &self.de.path,
+                key: variant,
+            },
+            remaining_depth: self.de.remaining_depth,
+        };
+        Ok((ret, variant_visitor))
+    }
+}
+
+impl<'de, 'a> de::VariantAccess<'de> for DeserializerFromEvents<'a> {
+    type Error = Error;
+
+    fn unit_variant(mut self) -> Result<()> {
+        Deserialize::deserialize(&mut self)
+    }
+
+    fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        seed.deserialize(&mut self)
+    }
+
+    fn tuple_variant<V>(mut self, _len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        de::Deserializer::deserialize_seq(&mut self, visitor)
+    }
+
+    fn struct_variant<V>(mut self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        de::Deserializer::deserialize_struct(&mut self, "", fields, visitor)
+    }
+}
+
+struct UnitVariantAccess<'a: 'r, 'r> {
+    de: &'r mut DeserializerFromEvents<'a>,
+}
+
+impl<'de, 'a, 'r> de::EnumAccess<'de> for UnitVariantAccess<'a, 'r> {
+    type Error = Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        Ok((seed.deserialize(&mut *self.de)?, self))
+    }
+}
+
+impl<'de, 'a, 'r> de::VariantAccess<'de> for UnitVariantAccess<'a, 'r> {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<()> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        Err(de::Error::invalid_type(
+            Unexpected::UnitVariant,
+            &"newtype variant",
+        ))
+    }
+
+    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::Error::invalid_type(
+            Unexpected::UnitVariant,
+            &"tuple variant",
+        ))
+    }
+
+    fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::Error::invalid_type(
+            Unexpected::UnitVariant,
+            &"struct variant",
+        ))
+    }
+}
+
+fn visit_untagged_str<'de, V>(visitor: V, v: &str) -> Result<V::Value>
+where
+    V: Visitor<'de>,
+{
+    if v == "~" || v == "null" {
+        return visitor.visit_unit();
+    }
+    if v == "true" {
+        return visitor.visit_bool(true);
+    }
+    if v == "false" {
+        return visitor.visit_bool(false);
+    }
+    if let Some(rest) = Option::or(v.strip_prefix("0x"), v.strip_prefix("+0x")) {
+        if let Ok(n) = u64::from_str_radix(rest, 16) {
+            return visitor.visit_u64(n);
+        }
+    }
+    if let Some(rest) = v.strip_prefix("-0x") {
+        let negative = format!("-{}", rest);
+        if let Ok(n) = i64::from_str_radix(&negative, 16) {
+            return visitor.visit_i64(n);
+        }
+    }
+    if let Some(rest) = Option::or(v.strip_prefix("0o"), v.strip_prefix("+0o")) {
+        if let Ok(n) = u64::from_str_radix(rest, 8) {
+            return visitor.visit_u64(n);
+        }
+    }
+    if let Some(rest) = v.strip_prefix("-0o") {
+        let negative = format!("-{}", rest);
+        if let Ok(n) = i64::from_str_radix(&negative, 8) {
+            return visitor.visit_i64(n);
+        }
+    }
+    if let Some(rest) = Option::or(v.strip_prefix("0b"), v.strip_prefix("+0b")) {
+        if let Ok(n) = u64::from_str_radix(rest, 2) {
+            return visitor.visit_u64(n);
+        }
+    }
+    if let Some(rest) = v.strip_prefix("-0b") {
+        let negative = format!("-{}", rest);
+        if let Ok(n) = i64::from_str_radix(&negative, 2) {
+            return visitor.visit_i64(n);
+        }
+    }
+    if {
+        let v = v.trim_start_matches(&['-', '+'][..]);
+        v.len() > 1 && v.starts_with('0') && v[1..].bytes().all(|b| b.is_ascii_digit())
+    } {
+        // After handling the different number encodings above if we are left
+        // with leading zero(s) followed by numeric characters this is in fact a
+        // string according to the YAML 1.2 spec.
+        // https://yaml.org/spec/1.2/spec.html#id2761292
+        return visitor.visit_str(v);
+    }
+    if let Ok(n) = v.parse() {
+        return visitor.visit_u64(n);
+    }
+    if let Ok(n) = v.parse() {
+        return visitor.visit_u128(n);
+    }
+    if let Ok(n) = v.parse() {
+        return visitor.visit_i64(n);
+    }
+    if let Ok(n) = v.parse() {
+        return visitor.visit_i128(n);
+    }
+    match v.trim_start_matches('+') {
+        ".inf" | ".Inf" | ".INF" => return visitor.visit_f64(f64::INFINITY),
+        _ => (),
+    }
+    if v == "-.inf" || v == "-.Inf" || v == "-.INF" {
+        return visitor.visit_f64(f64::NEG_INFINITY);
+    }
+    if v == ".nan" || v == ".NaN" || v == ".NAN" {
+        return visitor.visit_f64(f64::NAN);
+    }
+    if let Ok(n) = v.parse::<f64>() {
+        if n.is_finite() {
+            return visitor.visit_f64(n);
+        }
+    }
+    visitor.visit_str(v)
+}
+
+fn invalid_type(event: &Event, exp: &dyn Expected) -> Error {
+    enum Void {}
+
+    struct InvalidType<'a> {
+        exp: &'a dyn Expected,
+    }
+
+    impl<'de, 'a> Visitor<'de> for InvalidType<'a> {
+        type Value = Void;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            self.exp.fmt(formatter)
+        }
+    }
+
+    match event {
+        Event::Alias(_) => unreachable!(),
+        Event::Scalar(v, style, tag) => {
+            let get_type = InvalidType { exp };
+            match visit_scalar(v, *style, tag, get_type) {
+                Ok(void) => match void {},
+                Err(invalid_type) => invalid_type,
+            }
+        }
+        Event::SequenceStart => de::Error::invalid_type(Unexpected::Seq, exp),
+        Event::MappingStart => de::Error::invalid_type(Unexpected::Map, exp),
+        Event::SequenceEnd => panic!("unexpected end of sequence"),
+        Event::MappingEnd => panic!("unexpected end of mapping"),
+    }
+}
+
+impl<'a> DeserializerFromEvents<'a> {
+    fn deserialize_scalar<'de, V>(&mut self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.next()?;
+        match next {
+            Event::Alias(mut pos) => self.jump(&mut pos)?.deserialize_scalar(visitor),
+            Event::Scalar(v, style, tag) => visit_scalar(v, *style, tag, visitor),
+            other => Err(invalid_type(other, &visitor)),
+        }
+        .map_err(|err| error::fix_marker(err, marker, self.path))
+    }
+}
+
+impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut DeserializerFromEvents<'a> {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.next()?;
+        match next {
+            Event::Alias(mut pos) => self.jump(&mut pos)?.deserialize_any(visitor),
+            Event::Scalar(v, style, tag) => visit_scalar(v, *style, tag, visitor),
+            Event::SequenceStart => self.visit_sequence(visitor),
+            Event::MappingStart => self.visit_mapping(visitor),
+            Event::SequenceEnd => panic!("unexpected end of sequence"),
+            Event::MappingEnd => panic!("unexpected end of mapping"),
+        }
+        // The de::Error impl creates errors with unknown line and column. Fill
+        // in the position here by looking at the current index in the input.
+        .map_err(|err| error::fix_marker(err, marker, self.path))
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.next()?;
+        match next {
+            Event::Scalar(v, _, _) => visitor.visit_str(v),
+            Event::Alias(mut pos) => self.jump(&mut pos)?.deserialize_str(visitor),
+            other => Err(invalid_type(other, &visitor)),
+        }
+        .map_err(|err: Error| error::fix_marker(err, marker, self.path))
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_any(visitor)
+    }
+
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_bytes(visitor)
+    }
+
+    /// Parses `null` as None and any other values as `Some(...)`.
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let is_some = match self.peek()?.0 {
+            Event::Alias(mut pos) => {
+                *self.pos += 1;
+                return self.jump(&mut pos)?.deserialize_option(visitor);
+            }
+            Event::Scalar(v, style, tag) => {
+                if *style != TScalarStyle::Plain {
+                    true
+                } else if let Some(TokenType::Tag(handle, suffix)) = tag {
+                    if handle == "!!" && suffix == "null" {
+                        if v == "~" || v == "null" {
+                            false
+                        } else {
+                            return Err(de::Error::invalid_value(Unexpected::Str(v), &"null"));
+                        }
+                    } else {
+                        true
+                    }
+                } else {
+                    v != "~" && v != "null"
+                }
+            }
+            Event::SequenceStart | Event::MappingStart => true,
+            Event::SequenceEnd => panic!("unexpected end of sequence"),
+            Event::MappingEnd => panic!("unexpected end of mapping"),
+        };
+        if is_some {
+            visitor.visit_some(self)
+        } else {
+            *self.pos += 1;
+            visitor.visit_none()
+        }
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_scalar(visitor)
+    }
+
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    /// Parses a newtype struct as the underlying value.
+    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.next()?;
+        match next {
+            Event::Alias(mut pos) => self.jump(&mut pos)?.deserialize_seq(visitor),
+            Event::SequenceStart => self.visit_sequence(visitor),
+            other => Err(invalid_type(other, &visitor)),
+        }
+        .map_err(|err| error::fix_marker(err, marker, self.path))
+    }
+
+    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _name: &'static str,
+        _len: usize,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.next()?;
+        match next {
+            Event::Alias(mut pos) => self.jump(&mut pos)?.deserialize_map(visitor),
+            Event::MappingStart => self.visit_mapping(visitor),
+            other => Err(invalid_type(other, &visitor)),
+        }
+        .map_err(|err| error::fix_marker(err, marker, self.path))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.next()?;
+        match next {
+            Event::Alias(mut pos) => self
+                .jump(&mut pos)?
+                .deserialize_struct(name, fields, visitor),
+            Event::SequenceStart => self.visit_sequence(visitor),
+            Event::MappingStart => self.visit_mapping(visitor),
+            other => Err(invalid_type(other, &visitor)),
+        }
+        .map_err(|err| error::fix_marker(err, marker, self.path))
+    }
+
+    /// Parses an enum as a single key:value pair where the key identifies the
+    /// variant and the value gives the content. A String will also parse correctly
+    /// to a unit enum value.
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let (next, marker) = self.peek()?;
+        match next {
+            Event::Alias(mut pos) => {
+                *self.pos += 1;
+                self.jump(&mut pos)?
+                    .deserialize_enum(name, variants, visitor)
+            }
+            Event::Scalar(_, _, t) => {
+                if let Some(TokenType::Tag(handle, suffix)) = t {
+                    if handle == "!" {
+                        if let Some(tag) = variants.iter().find(|v| *v == suffix) {
+                            return visitor.visit_enum(EnumAccess {
+                                de: self,
+                                name,
+                                tag: Some(tag),
+                            });
+                        }
+                    }
+                }
+                visitor.visit_enum(UnitVariantAccess { de: self })
+            }
+            Event::MappingStart => {
+                *self.pos += 1;
+                let value = visitor.visit_enum(EnumAccess {
+                    de: self,
+                    name,
+                    tag: None,
+                })?;
+                self.end_mapping(1)?;
+                Ok(value)
+            }
+            Event::SequenceStart => {
+                let err = de::Error::invalid_type(Unexpected::Seq, &"string or singleton map");
+                Err(error::fix_marker(err, marker, self.path))
+            }
+            Event::SequenceEnd => panic!("unexpected end of sequence"),
+            Event::MappingEnd => panic!("unexpected end of mapping"),
+        }
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.ignore_any();
+        visitor.visit_unit()
+    }
+}
+
+/// Deserialize an instance of type `T` from a string of YAML text.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// YAML currently does not support zero-copy deserialization.
+pub fn from_str<T>(s: &str) -> Result<T>
+where
+    T: DeserializeOwned,
+{
+    from_str_seed(s, PhantomData)
+}
+
+/// Deserialize an instance of type `T` from a string of YAML text with a seed.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// YAML currently does not support zero-copy deserialization.
+pub fn from_str_seed<T, S>(s: &str, seed: S) -> Result<T>
+where
+    S: for<'de> DeserializeSeed<'de, Value = T>,
+{
+    seed.deserialize(Deserializer::from_str(s))
+}
+
+/// Deserialize an instance of type `T` from an IO stream of YAML.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+pub fn from_reader<R, T>(rdr: R) -> Result<T>
+where
+    R: io::Read,
+    T: DeserializeOwned,
+{
+    from_reader_seed(rdr, PhantomData)
+}
+
+/// Deserialize an instance of type `T` from an IO stream of YAML with a seed.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+pub fn from_reader_seed<R, T, S>(rdr: R, seed: S) -> Result<T>
+where
+    R: io::Read,
+    S: for<'de> DeserializeSeed<'de, Value = T>,
+{
+    seed.deserialize(Deserializer::from_reader(rdr))
+}
+
+/// Deserialize an instance of type `T` from bytes of YAML text.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// YAML currently does not support zero-copy deserialization.
+pub fn from_slice<T>(v: &[u8]) -> Result<T>
+where
+    T: DeserializeOwned,
+{
+    from_slice_seed(v, PhantomData)
+}
+
+/// Deserialize an instance of type `T` from bytes of YAML text with a seed.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// YAML currently does not support zero-copy deserialization.
+pub fn from_slice_seed<T, S>(v: &[u8], seed: S) -> Result<T>
+where
+    S: for<'de> DeserializeSeed<'de, Value = T>,
+{
+    seed.deserialize(Deserializer::from_slice(v))
+}
diff --git a/third_party/rust/serde_yaml/src/error.rs b/third_party/rust/serde_yaml/src/error.rs
new file mode 100644
index 0000000000..dc8321435f
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/error.rs
@@ -0,0 +1,244 @@
+use crate::path::Path;
+use serde::{de, ser};
+use std::error;
+use std::fmt::{self, Debug, Display};
+use std::io;
+use std::result;
+use std::str;
+use std::string;
+use std::sync::Arc;
+use yaml_rust::emitter;
+use yaml_rust::scanner::{self, Marker, ScanError};
+
+/// An error that happened serializing or deserializing YAML data.
+pub struct Error(Box<ErrorImpl>);
+
+/// Alias for a `Result` with the error type `serde_yaml::Error`.
+pub type Result<T> = result::Result<T, Error>;
+
+#[derive(Debug)]
+pub enum ErrorImpl {
+    Message(String, Option<Pos>),
+
+    Emit(emitter::EmitError),
+    Scan(scanner::ScanError),
+    Io(io::Error),
+    Utf8(str::Utf8Error),
+    FromUtf8(string::FromUtf8Error),
+
+    EndOfStream,
+    MoreThanOneDocument,
+    RecursionLimitExceeded,
+
+    Shared(Arc<ErrorImpl>),
+}
+
+#[derive(Debug)]
+pub struct Pos {
+    marker: Marker,
+    path: String,
+}
+
+/// The input location that an error occured.
+#[derive(Debug)]
+pub struct Location {
+    index: usize,
+    line: usize,
+    column: usize,
+}
+
+impl Location {
+    /// The byte index of the error
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// The line of the error
+    pub fn line(&self) -> usize {
+        self.line
+    }
+
+    /// The column of the error
+    pub fn column(&self) -> usize {
+        self.column
+    }
+
+    // This is to keep decoupled with the yaml crate
+    #[doc(hidden)]
+    fn from_marker(marker: &Marker) -> Self {
+        Location {
+            // `col` returned from the `yaml` crate is 0-indexed but all error messages add + 1 to this value
+            column: marker.col() + 1,
+            index: marker.index(),
+            line: marker.line(),
+        }
+    }
+}
+
+impl Error {
+    /// Returns the Location from the error if one exists.
+    ///
+    /// Not all types of errors have a location so this can return `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::{Value, Error};
+    /// #
+    /// // The `@` character as the first character makes this invalid yaml
+    /// let invalid_yaml: Result<Value, Error> = serde_yaml::from_str("@invalid_yaml");
+    ///
+    /// let location = invalid_yaml.unwrap_err().location().unwrap();
+    ///
+    /// assert_eq!(location.line(), 1);
+    /// assert_eq!(location.column(), 1);
+    /// ```
+    pub fn location(&self) -> Option<Location> {
+        match self.0.as_ref() {
+            ErrorImpl::Message(_, Some(pos)) => Some(Location::from_marker(&pos.marker)),
+            ErrorImpl::Scan(scan) => Some(Location::from_marker(scan.marker())),
+            _ => None,
+        }
+    }
+}
+
+pub(crate) fn end_of_stream() -> Error {
+    Error(Box::new(ErrorImpl::EndOfStream))
+}
+
+pub(crate) fn more_than_one_document() -> Error {
+    Error(Box::new(ErrorImpl::MoreThanOneDocument))
+}
+
+pub(crate) fn io(err: io::Error) -> Error {
+    Error(Box::new(ErrorImpl::Io(err)))
+}
+
+pub(crate) fn emitter(err: emitter::EmitError) -> Error {
+    Error(Box::new(ErrorImpl::Emit(err)))
+}
+
+pub(crate) fn scanner(err: scanner::ScanError) -> Error {
+    Error(Box::new(ErrorImpl::Scan(err)))
+}
+
+pub(crate) fn str_utf8(err: str::Utf8Error) -> Error {
+    Error(Box::new(ErrorImpl::Utf8(err)))
+}
+
+pub(crate) fn string_utf8(err: string::FromUtf8Error) -> Error {
+    Error(Box::new(ErrorImpl::FromUtf8(err)))
+}
+
+pub(crate) fn recursion_limit_exceeded() -> Error {
+    Error(Box::new(ErrorImpl::RecursionLimitExceeded))
+}
+
+pub(crate) fn shared(shared: Arc<ErrorImpl>) -> Error {
+    Error(Box::new(ErrorImpl::Shared(shared)))
+}
+
+pub(crate) fn fix_marker(mut error: Error, marker: Marker, path: Path) -> Error {
+    if let ErrorImpl::Message(_, none @ None) = error.0.as_mut() {
+        *none = Some(Pos {
+            marker,
+            path: path.to_string(),
+        });
+    }
+    error
+}
+
+impl Error {
+    pub(crate) fn shared(self) -> Arc<ErrorImpl> {
+        if let ErrorImpl::Shared(err) = *self.0 {
+            err
+        } else {
+            Arc::from(self.0)
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        self.0.source()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.display(f)
+    }
+}
+
+// Remove two layers of verbosity from the debug representation. Humans often
+// end up seeing this representation because it is what unwrap() shows.
+impl Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.debug(f)
+    }
+}
+
+impl ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error(Box::new(ErrorImpl::Message(msg.to_string(), None)))
+    }
+}
+
+impl de::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error(Box::new(ErrorImpl::Message(msg.to_string(), None)))
+    }
+}
+
+impl ErrorImpl {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            ErrorImpl::Scan(err) => Some(err),
+            ErrorImpl::Io(err) => Some(err),
+            ErrorImpl::Utf8(err) => Some(err),
+            ErrorImpl::FromUtf8(err) => Some(err),
+            ErrorImpl::Shared(err) => err.source(),
+            _ => None,
+        }
+    }
+
+    fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ErrorImpl::Message(msg, None) => Display::fmt(msg, f),
+            ErrorImpl::Message(msg, Some(Pos { marker, path })) => {
+                if path == "." {
+                    write!(f, "{}", ScanError::new(*marker, msg))
+                } else {
+                    write!(f, "{}: {}", path, ScanError::new(*marker, msg))
+                }
+            }
+            ErrorImpl::Emit(emitter::EmitError::FmtError(_)) => f.write_str("yaml-rust fmt error"),
+            ErrorImpl::Emit(emitter::EmitError::BadHashmapKey) => f.write_str("bad hash map key"),
+            ErrorImpl::Scan(err) => Display::fmt(err, f),
+            ErrorImpl::Io(err) => Display::fmt(err, f),
+            ErrorImpl::Utf8(err) => Display::fmt(err, f),
+            ErrorImpl::FromUtf8(err) => Display::fmt(err, f),
+            ErrorImpl::EndOfStream => f.write_str("EOF while parsing a value"),
+            ErrorImpl::MoreThanOneDocument => f.write_str(
+                "deserializing from YAML containing more than one document is not supported",
+            ),
+            ErrorImpl::RecursionLimitExceeded => f.write_str("recursion limit exceeded"),
+            ErrorImpl::Shared(err) => err.display(f),
+        }
+    }
+
+    fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ErrorImpl::Message(msg, pos) => f.debug_tuple("Message").field(msg).field(pos).finish(),
+            ErrorImpl::Emit(emit) => f.debug_tuple("Emit").field(emit).finish(),
+            ErrorImpl::Scan(scan) => f.debug_tuple("Scan").field(scan).finish(),
+            ErrorImpl::Io(io) => f.debug_tuple("Io").field(io).finish(),
+            ErrorImpl::Utf8(utf8) => f.debug_tuple("Utf8").field(utf8).finish(),
+            ErrorImpl::FromUtf8(from_utf8) => f.debug_tuple("FromUtf8").field(from_utf8).finish(),
+            ErrorImpl::EndOfStream => f.debug_tuple("EndOfStream").finish(),
+            ErrorImpl::MoreThanOneDocument => f.debug_tuple("MoreThanOneDocument").finish(),
+            ErrorImpl::RecursionLimitExceeded => f.debug_tuple("RecursionLimitExceeded").finish(),
+            ErrorImpl::Shared(err) => err.debug(f),
+        }
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/lib.rs b/third_party/rust/serde_yaml/src/lib.rs
new file mode 100644
index 0000000000..f3fc6a9d3c
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/lib.rs
@@ -0,0 +1,125 @@
+//! [![github]](https://github.com/dtolnay/serde-yaml)&ensp;[![crates-io]](https://crates.io/crates/serde-yaml)&ensp;[![docs-rs]](https://docs.rs/serde-yaml)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
+//!
+//! <br>
+//!
+//! This crate is a Rust library for using the [Serde] serialization framework
+//! with data in [YAML] file format.
+//!
+//! This library does not reimplement a YAML parser; it uses [yaml-rust] which
+//! is a pure Rust YAML 1.2 implementation.
+//!
+//! [Serde]: https://github.com/serde-rs/serde
+//! [YAML]: https://yaml.org/
+//! [yaml-rust]: https://github.com/chyh1990/yaml-rust
+//!
+//! # Examples
+//!
+//! ```
+//! use std::collections::BTreeMap;
+//!
+//! fn main() -> Result<(), serde_yaml::Error> {
+//!     // You have some type.
+//!     let mut map = BTreeMap::new();
+//!     map.insert("x".to_string(), 1.0);
+//!     map.insert("y".to_string(), 2.0);
+//!
+//!     // Serialize it to a YAML string.
+//!     let s = serde_yaml::to_string(&map)?;
+//!     assert_eq!(s, "---\nx: 1.0\ny: 2.0\n");
+//!
+//!     // Deserialize it back to a Rust type.
+//!     let deserialized_map: BTreeMap<String, f64> = serde_yaml::from_str(&s)?;
+//!     assert_eq!(map, deserialized_map);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ## Using Serde derive
+//!
+//! It can also be used with Serde's serialization code generator `serde_derive` to
+//! handle structs and enums defined in your own program.
+//!
+//! ```
+//! # use serde_derive::{Serialize, Deserialize};
+//! use serde::{Serialize, Deserialize};
+//!
+//! #[derive(Debug, PartialEq, Serialize, Deserialize)]
+//! struct Point {
+//!     x: f64,
+//!     y: f64,
+//! }
+//!
+//! fn main() -> Result<(), serde_yaml::Error> {
+//!     let point = Point { x: 1.0, y: 2.0 };
+//!
+//!     let s = serde_yaml::to_string(&point)?;
+//!     assert_eq!(s, "---\nx: 1.0\ny: 2.0\n");
+//!
+//!     let deserialized_point: Point = serde_yaml::from_str(&s)?;
+//!     assert_eq!(point, deserialized_point);
+//!     Ok(())
+//! }
+//! ```
+
+#![doc(html_root_url = "https://docs.rs/serde_yaml/0.8.26")]
+#![deny(missing_docs)]
+// Suppressed clippy_pedantic lints
+#![allow(
+    // buggy
+    clippy::iter_not_returning_iterator, // https://github.com/rust-lang/rust-clippy/issues/8285
+    clippy::question_mark, // https://github.com/rust-lang/rust-clippy/issues/7859
+    // private Deserializer::next
+    clippy::should_implement_trait,
+    // things are often more readable this way
+    clippy::cast_lossless,
+    clippy::checked_conversions,
+    clippy::if_not_else,
+    clippy::manual_assert,
+    clippy::match_like_matches_macro,
+    clippy::match_same_arms,
+    clippy::module_name_repetitions,
+    clippy::needless_pass_by_value,
+    clippy::option_if_let_else,
+    clippy::redundant_else,
+    clippy::single_match_else,
+    // code is acceptable
+    clippy::blocks_in_if_conditions,
+    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
+    clippy::derive_partial_eq_without_eq,
+    clippy::doc_markdown,
+    clippy::items_after_statements,
+    clippy::return_self_not_must_use,
+    // noisy
+    clippy::missing_errors_doc,
+    clippy::must_use_candidate,
+)]
+
+pub use crate::de::{from_reader, from_slice, from_str, Deserializer};
+pub use crate::error::{Error, Location, Result};
+pub use crate::ser::{to_string, to_vec, to_writer, Serializer};
+pub use crate::value::{from_value, to_value, Index, Number, Sequence, Value};
+
+#[doc(inline)]
+pub use crate::mapping::Mapping;
+
+/// Entry points for deserializing with pre-existing state.
+///
+/// These functions are only exposed this way because we don't yet expose a
+/// Deserializer type. Data formats that have a public Deserializer should not
+/// copy these signatures.
+pub mod seed {
+    pub use super::de::{from_reader_seed, from_slice_seed, from_str_seed};
+}
+
+mod de;
+mod error;
+pub mod mapping;
+mod number;
+mod path;
+mod ser;
+mod value;
diff --git a/third_party/rust/serde_yaml/src/mapping.rs b/third_party/rust/serde_yaml/src/mapping.rs
new file mode 100644
index 0000000000..89f6e413a0
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/mapping.rs
@@ -0,0 +1,512 @@
+//! A YAML mapping and its iterator types.
+
+use crate::Value;
+use indexmap::IndexMap;
+use serde::{Deserialize, Deserializer, Serialize};
+use std::cmp::Ordering;
+use std::collections::hash_map::DefaultHasher;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::iter::FromIterator;
+use std::ops::{Index, IndexMut};
+
+/// A YAML mapping in which the keys and values are both `serde_yaml::Value`.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct Mapping {
+    map: IndexMap<Value, Value>,
+}
+
+impl Mapping {
+    /// Creates an empty YAML map.
+    #[inline]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Creates an empty YAML map with the given initial capacity.
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> Self {
+        Mapping {
+            map: IndexMap::with_capacity(capacity),
+        }
+    }
+
+    /// Reserves capacity for at least `additional` more elements to be inserted
+    /// into the map. The map may reserve more space to avoid frequent
+    /// allocations.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new allocation size overflows `usize`.
+    #[inline]
+    pub fn reserve(&mut self, additional: usize) {
+        self.map.reserve(additional);
+    }
+
+    /// Shrinks the capacity of the map as much as possible. It will drop down
+    /// as much as possible while maintaining the internal rules and possibly
+    /// leaving some space in accordance with the resize policy.
+    #[inline]
+    pub fn shrink_to_fit(&mut self) {
+        self.map.shrink_to_fit();
+    }
+
+    /// Inserts a key-value pair into the map. If the key already existed, the
+    /// old value is returned.
+    #[inline]
+    pub fn insert(&mut self, k: Value, v: Value) -> Option<Value> {
+        self.map.insert(k, v)
+    }
+
+    /// Checks if the map contains the given key.
+    #[inline]
+    pub fn contains_key(&self, k: &Value) -> bool {
+        self.map.contains_key(k)
+    }
+
+    /// Returns the value corresponding to the key in the map.
+    #[inline]
+    pub fn get(&self, k: &Value) -> Option<&Value> {
+        self.map.get(k)
+    }
+
+    /// Returns the mutable reference corresponding to the key in the map.
+    #[inline]
+    pub fn get_mut(&mut self, k: &Value) -> Option<&mut Value> {
+        self.map.get_mut(k)
+    }
+
+    /// Gets the given key’s corresponding entry in the map for insertion and/or
+    /// in-place manipulation.
+    #[inline]
+    pub fn entry(&mut self, k: Value) -> Entry {
+        match self.map.entry(k) {
+            indexmap::map::Entry::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied }),
+            indexmap::map::Entry::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant }),
+        }
+    }
+
+    /// Removes and returns the value corresponding to the key from the map.
+    #[inline]
+    pub fn remove(&mut self, k: &Value) -> Option<Value> {
+        self.map.remove(k)
+    }
+
+    /// Returns the maximum number of key-value pairs the map can hold without
+    /// reallocating.
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.map.capacity()
+    }
+
+    /// Returns the number of key-value pairs in the map.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Returns whether the map is currently empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+
+    /// Clears the map of all key-value pairs.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.map.clear();
+    }
+
+    /// Returns a double-ended iterator visiting all key-value pairs in order of
+    /// insertion. Iterator element type is `(&'a Value, &'a Value)`.
+    #[inline]
+    pub fn iter(&self) -> Iter {
+        Iter {
+            iter: self.map.iter(),
+        }
+    }
+
+    /// Returns a double-ended iterator visiting all key-value pairs in order of
+    /// insertion. Iterator element type is `(&'a Value, &'a mut ValuE)`.
+    #[inline]
+    pub fn iter_mut(&mut self) -> IterMut {
+        IterMut {
+            iter: self.map.iter_mut(),
+        }
+    }
+}
+
+#[allow(clippy::derive_hash_xor_eq)]
+impl Hash for Mapping {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // Hash the kv pairs in a way that is not sensitive to their order.
+        let mut xor = 0;
+        for (k, v) in self {
+            let mut hasher = DefaultHasher::new();
+            k.hash(&mut hasher);
+            v.hash(&mut hasher);
+            xor ^= hasher.finish();
+        }
+        xor.hash(state);
+    }
+}
+
+impl PartialOrd for Mapping {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        let mut self_entries = Vec::from_iter(self);
+        let mut other_entries = Vec::from_iter(other);
+
+        // Sort in an arbitrary order that is consistent with Value's PartialOrd
+        // impl.
+        fn total_cmp(a: &Value, b: &Value) -> Ordering {
+            match (a, b) {
+                (Value::Null, Value::Null) => Ordering::Equal,
+                (Value::Null, _) => Ordering::Less,
+                (_, Value::Null) => Ordering::Greater,
+
+                (Value::Bool(a), Value::Bool(b)) => a.cmp(b),
+                (Value::Bool(_), _) => Ordering::Less,
+                (_, Value::Bool(_)) => Ordering::Greater,
+
+                (Value::Number(a), Value::Number(b)) => a.total_cmp(b),
+                (Value::Number(_), _) => Ordering::Less,
+                (_, Value::Number(_)) => Ordering::Greater,
+
+                (Value::String(a), Value::String(b)) => a.cmp(b),
+                (Value::String(_), _) => Ordering::Less,
+                (_, Value::String(_)) => Ordering::Greater,
+
+                (Value::Sequence(a), Value::Sequence(b)) => iter_cmp_by(a, b, total_cmp),
+                (Value::Sequence(_), _) => Ordering::Less,
+                (_, Value::Sequence(_)) => Ordering::Greater,
+
+                (Value::Mapping(a), Value::Mapping(b)) => {
+                    iter_cmp_by(a, b, |(ak, av), (bk, bv)| {
+                        total_cmp(ak, bk).then_with(|| total_cmp(av, bv))
+                    })
+                }
+            }
+        }
+
+        fn iter_cmp_by<I, F>(this: I, other: I, mut cmp: F) -> Ordering
+        where
+            I: IntoIterator,
+            F: FnMut(I::Item, I::Item) -> Ordering,
+        {
+            let mut this = this.into_iter();
+            let mut other = other.into_iter();
+
+            loop {
+                let x = match this.next() {
+                    None => {
+                        if other.next().is_none() {
+                            return Ordering::Equal;
+                        } else {
+                            return Ordering::Less;
+                        }
+                    }
+                    Some(val) => val,
+                };
+
+                let y = match other.next() {
+                    None => return Ordering::Greater,
+                    Some(val) => val,
+                };
+
+                match cmp(x, y) {
+                    Ordering::Equal => {}
+                    non_eq => return non_eq,
+                }
+            }
+        }
+
+        // While sorting by map key, we get to assume that no two keys are
+        // equal, otherwise they wouldn't both be in the map. This is not a safe
+        // assumption outside of this situation.
+        let total_cmp = |&(a, _): &_, &(b, _): &_| total_cmp(a, b);
+        self_entries.sort_by(total_cmp);
+        other_entries.sort_by(total_cmp);
+        self_entries.partial_cmp(&other_entries)
+    }
+}
+
+impl<'a> Index<&'a Value> for Mapping {
+    type Output = Value;
+    #[inline]
+    fn index(&self, index: &'a Value) -> &Value {
+        self.map.index(index)
+    }
+}
+
+impl<'a> IndexMut<&'a Value> for Mapping {
+    #[inline]
+    fn index_mut(&mut self, index: &'a Value) -> &mut Value {
+        self.map.index_mut(index)
+    }
+}
+
+impl Extend<(Value, Value)> for Mapping {
+    #[inline]
+    fn extend<I: IntoIterator<Item = (Value, Value)>>(&mut self, iter: I) {
+        self.map.extend(iter);
+    }
+}
+
+impl FromIterator<(Value, Value)> for Mapping {
+    #[inline]
+    fn from_iter<I: IntoIterator<Item = (Value, Value)>>(iter: I) -> Self {
+        Mapping {
+            map: IndexMap::from_iter(iter),
+        }
+    }
+}
+
+macro_rules! delegate_iterator {
+    (($name:ident $($generics:tt)*) => $item:ty) => {
+        impl $($generics)* Iterator for $name $($generics)* {
+            type Item = $item;
+            #[inline]
+            fn next(&mut self) -> Option<Self::Item> {
+                self.iter.next()
+            }
+            #[inline]
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                self.iter.size_hint()
+            }
+        }
+
+        impl $($generics)* ExactSizeIterator for $name $($generics)* {
+            #[inline]
+            fn len(&self) -> usize {
+                self.iter.len()
+            }
+        }
+    }
+}
+
+/// Iterator over `&serde_yaml::Mapping`.
+pub struct Iter<'a> {
+    iter: indexmap::map::Iter<'a, Value, Value>,
+}
+
+delegate_iterator!((Iter<'a>) => (&'a Value, &'a Value));
+
+impl<'a> IntoIterator for &'a Mapping {
+    type Item = (&'a Value, &'a Value);
+    type IntoIter = Iter<'a>;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        Iter {
+            iter: self.map.iter(),
+        }
+    }
+}
+
+/// Iterator over `&mut serde_yaml::Mapping`.
+pub struct IterMut<'a> {
+    iter: indexmap::map::IterMut<'a, Value, Value>,
+}
+
+delegate_iterator!((IterMut<'a>) => (&'a Value, &'a mut Value));
+
+impl<'a> IntoIterator for &'a mut Mapping {
+    type Item = (&'a Value, &'a mut Value);
+    type IntoIter = IterMut<'a>;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        IterMut {
+            iter: self.map.iter_mut(),
+        }
+    }
+}
+
+/// Iterator over `serde_yaml::Mapping` by value.
+pub struct IntoIter {
+    iter: indexmap::map::IntoIter<Value, Value>,
+}
+
+delegate_iterator!((IntoIter) => (Value, Value));
+
+impl IntoIterator for Mapping {
+    type Item = (Value, Value);
+    type IntoIter = IntoIter;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter {
+            iter: self.map.into_iter(),
+        }
+    }
+}
+
+/// Entry for an existing key-value pair or a vacant location to insert one.
+pub enum Entry<'a> {
+    /// Existing slot with equivalent key.
+    Occupied(OccupiedEntry<'a>),
+    /// Vacant slot (no equivalent key in the map).
+    Vacant(VacantEntry<'a>),
+}
+
+/// A view into an occupied entry in a [`Mapping`]. It is part of the [`Entry`]
+/// enum.
+pub struct OccupiedEntry<'a> {
+    occupied: indexmap::map::OccupiedEntry<'a, Value, Value>,
+}
+
+/// A view into a vacant entry in a [`Mapping`]. It is part of the [`Entry`]
+/// enum.
+pub struct VacantEntry<'a> {
+    vacant: indexmap::map::VacantEntry<'a, Value, Value>,
+}
+
+impl<'a> Entry<'a> {
+    /// Returns a reference to this entry's key.
+    pub fn key(&self) -> &Value {
+        match self {
+            Entry::Vacant(e) => e.key(),
+            Entry::Occupied(e) => e.key(),
+        }
+    }
+
+    /// Ensures a value is in the entry by inserting the default if empty, and
+    /// returns a mutable reference to the value in the entry.
+    pub fn or_insert(self, default: Value) -> &'a mut Value {
+        match self {
+            Entry::Vacant(entry) => entry.insert(default),
+            Entry::Occupied(entry) => entry.into_mut(),
+        }
+    }
+
+    /// Ensures a value is in the entry by inserting the result of the default
+    /// function if empty, and returns a mutable reference to the value in the
+    /// entry.
+    pub fn or_insert_with<F>(self, default: F) -> &'a mut Value
+    where
+        F: FnOnce() -> Value,
+    {
+        match self {
+            Entry::Vacant(entry) => entry.insert(default()),
+            Entry::Occupied(entry) => entry.into_mut(),
+        }
+    }
+
+    /// Provides in-place mutable access to an occupied entry before any
+    /// potential inserts into the map.
+    pub fn and_modify<F>(self, f: F) -> Self
+    where
+        F: FnOnce(&mut Value),
+    {
+        match self {
+            Entry::Occupied(mut entry) => {
+                f(entry.get_mut());
+                Entry::Occupied(entry)
+            }
+            Entry::Vacant(entry) => Entry::Vacant(entry),
+        }
+    }
+}
+
+impl<'a> OccupiedEntry<'a> {
+    /// Gets a reference to the key in the entry.
+    #[inline]
+    pub fn key(&self) -> &Value {
+        self.occupied.key()
+    }
+
+    /// Gets a reference to the value in the entry.
+    #[inline]
+    pub fn get(&self) -> &Value {
+        self.occupied.get()
+    }
+
+    /// Gets a mutable reference to the value in the entry.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut Value {
+        self.occupied.get_mut()
+    }
+
+    /// Converts the entry into a mutable reference to its value.
+    #[inline]
+    pub fn into_mut(self) -> &'a mut Value {
+        self.occupied.into_mut()
+    }
+
+    /// Sets the value of the entry with the `OccupiedEntry`'s key, and returns
+    /// the entry's old value.
+    #[inline]
+    pub fn insert(&mut self, value: Value) -> Value {
+        self.occupied.insert(value)
+    }
+
+    /// Takes the value of the entry out of the map, and returns it.
+    #[inline]
+    pub fn remove(self) -> Value {
+        self.occupied.swap_remove()
+    }
+}
+
+impl<'a> VacantEntry<'a> {
+    /// Gets a reference to the key that would be used when inserting a value
+    /// through the VacantEntry.
+    #[inline]
+    pub fn key(&self) -> &Value {
+        self.vacant.key()
+    }
+
+    /// Sets the value of the entry with the VacantEntry's key, and returns a
+    /// mutable reference to it.
+    #[inline]
+    pub fn insert(self, value: Value) -> &'a mut Value {
+        self.vacant.insert(value)
+    }
+}
+
+impl Serialize for Mapping {
+    #[inline]
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::SerializeMap;
+        let mut map_serializer = serializer.serialize_map(Some(self.len()))?;
+        for (k, v) in self {
+            map_serializer.serialize_entry(k, v)?;
+        }
+        map_serializer.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for Mapping {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = Mapping;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a YAML mapping")
+            }
+
+            #[inline]
+            fn visit_unit<E>(self) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Mapping::new())
+            }
+
+            #[inline]
+            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut values = Mapping::new();
+                while let Some((k, v)) = visitor.next_entry()? {
+                    values.insert(k, v);
+                }
+                Ok(values)
+            }
+        }
+
+        deserializer.deserialize_map(Visitor)
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/number.rs b/third_party/rust/serde_yaml/src/number.rs
new file mode 100644
index 0000000000..b3643ba8b1
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/number.rs
@@ -0,0 +1,550 @@
+use crate::Error;
+use serde::de::{Unexpected, Visitor};
+use serde::{forward_to_deserialize_any, Deserialize, Deserializer, Serialize, Serializer};
+use std::cmp::Ordering;
+use std::fmt::{self, Debug, Display};
+use std::hash::{Hash, Hasher};
+use std::i64;
+
+/// Represents a YAML number, whether integer or floating point.
+#[derive(Clone, PartialEq, PartialOrd)]
+pub struct Number {
+    n: N,
+}
+
+// "N" is a prefix of "NegInt"... this is a false positive.
+// https://github.com/Manishearth/rust-clippy/issues/1241
+#[allow(clippy::enum_variant_names)]
+#[derive(Copy, Clone, Debug)]
+enum N {
+    PosInt(u64),
+    /// Always less than zero.
+    NegInt(i64),
+    /// May be infinite or NaN.
+    Float(f64),
+}
+
+impl Number {
+    /// Returns true if the `Number` is an integer between `i64::MIN` and
+    /// `i64::MAX`.
+    ///
+    /// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to
+    /// return the integer value.
+    ///
+    /// ```
+    /// # use std::i64;
+    /// #
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let big = i64::MAX as u64 + 10;
+    /// let v = yaml(r#"
+    /// a: 64
+    /// b: 9223372036854775817
+    /// c: 256.0
+    /// "#);
+    ///
+    /// assert!(v["a"].is_i64());
+    ///
+    /// // Greater than i64::MAX.
+    /// assert!(!v["b"].is_i64());
+    ///
+    /// // Numbers with a decimal point are not considered integers.
+    /// assert!(!v["c"].is_i64());
+    /// ```
+    #[inline]
+    #[allow(clippy::cast_sign_loss)]
+    pub fn is_i64(&self) -> bool {
+        match self.n {
+            N::PosInt(v) => v <= i64::max_value() as u64,
+            N::NegInt(_) => true,
+            N::Float(_) => false,
+        }
+    }
+
+    /// Returns true if the `Number` is an integer between zero and `u64::MAX`.
+    ///
+    /// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to
+    /// return the integer value.
+    ///
+    /// ```
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let v = yaml(r#"
+    /// a: 64
+    /// b: -64
+    /// c: 256.0
+    /// "#);
+    ///
+    /// assert!(v["a"].is_u64());
+    ///
+    /// // Negative integer.
+    /// assert!(!v["b"].is_u64());
+    ///
+    /// // Numbers with a decimal point are not considered integers.
+    /// assert!(!v["c"].is_u64());
+    /// ```
+    #[inline]
+    pub fn is_u64(&self) -> bool {
+        match self.n {
+            N::PosInt(_) => true,
+            N::NegInt(_) | N::Float(_) => false,
+        }
+    }
+
+    /// Returns true if the `Number` can be represented by f64.
+    ///
+    /// For any Number on which `is_f64` returns true, `as_f64` is guaranteed to
+    /// return the floating point value.
+    ///
+    /// Currently this function returns true if and only if both `is_i64` and
+    /// `is_u64` return false but this is not a guarantee in the future.
+    ///
+    /// ```
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let v = yaml(r#"
+    /// ---
+    /// a: 256.0
+    /// b: 64
+    /// c: -64
+    /// "#);
+    ///
+    /// assert!(v["a"].is_f64());
+    ///
+    /// // Integers.
+    /// assert!(!v["b"].is_f64());
+    /// assert!(!v["c"].is_f64());
+    /// ```
+    #[inline]
+    pub fn is_f64(&self) -> bool {
+        match self.n {
+            N::Float(_) => true,
+            N::PosInt(_) | N::NegInt(_) => false,
+        }
+    }
+
+    /// If the `Number` is an integer, represent it as i64 if possible. Returns
+    /// None otherwise.
+    ///
+    /// ```
+    /// # use std::i64;
+    /// #
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let big = i64::MAX as u64 + 10;
+    /// let v = yaml(r#"
+    /// ---
+    /// a: 64
+    /// b: 9223372036854775817
+    /// c: 256.0
+    /// "#);
+    ///
+    /// assert_eq!(v["a"].as_i64(), Some(64));
+    /// assert_eq!(v["b"].as_i64(), None);
+    /// assert_eq!(v["c"].as_i64(), None);
+    /// ```
+    #[inline]
+    pub fn as_i64(&self) -> Option<i64> {
+        match self.n {
+            N::PosInt(n) => {
+                if n <= i64::max_value() as u64 {
+                    Some(n as i64)
+                } else {
+                    None
+                }
+            }
+            N::NegInt(n) => Some(n),
+            N::Float(_) => None,
+        }
+    }
+
+    /// If the `Number` is an integer, represent it as u64 if possible. Returns
+    /// None otherwise.
+    ///
+    /// ```
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let v = yaml(r#"
+    /// ---
+    /// a: 64
+    /// b: -64
+    /// c: 256.0
+    /// "#);
+    ///
+    /// assert_eq!(v["a"].as_u64(), Some(64));
+    /// assert_eq!(v["b"].as_u64(), None);
+    /// assert_eq!(v["c"].as_u64(), None);
+    /// ```
+    #[inline]
+    pub fn as_u64(&self) -> Option<u64> {
+        match self.n {
+            N::PosInt(n) => Some(n),
+            N::NegInt(_) | N::Float(_) => None,
+        }
+    }
+
+    /// Represents the number as f64 if possible. Returns None otherwise.
+    ///
+    /// ```
+    /// #
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// let v = yaml(r#"
+    /// ---
+    /// a: 256.0
+    /// b: 64
+    /// c: -64
+    /// "#);
+    ///
+    /// assert_eq!(v["a"].as_f64(), Some(256.0));
+    /// assert_eq!(v["b"].as_f64(), Some(64.0));
+    /// assert_eq!(v["c"].as_f64(), Some(-64.0));
+    /// ```
+    ///
+    /// ```
+    /// # use std::f64;
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// assert_eq!(yaml(".inf").as_f64(), Some(f64::INFINITY));
+    /// assert_eq!(yaml("-.inf").as_f64(), Some(f64::NEG_INFINITY));
+    /// assert!(yaml(".nan").as_f64().unwrap().is_nan());
+    /// ```
+    #[inline]
+    pub fn as_f64(&self) -> Option<f64> {
+        match self.n {
+            N::PosInt(n) => Some(n as f64),
+            N::NegInt(n) => Some(n as f64),
+            N::Float(n) => Some(n),
+        }
+    }
+
+    /// Returns true if this value is NaN and false otherwise.
+    ///
+    /// ```
+    /// # use std::f64;
+    /// #
+    /// # use serde_yaml::Number;
+    /// #
+    /// assert!(!Number::from(256.0).is_nan());
+    ///
+    /// assert!(Number::from(f64::NAN).is_nan());
+    ///
+    /// assert!(!Number::from(f64::INFINITY).is_nan());
+    ///
+    /// assert!(!Number::from(f64::NEG_INFINITY).is_nan());
+    ///
+    /// assert!(!Number::from(1).is_nan());
+    /// ```
+    #[inline]
+    pub fn is_nan(&self) -> bool {
+        match self.n {
+            N::PosInt(_) | N::NegInt(_) => false,
+            N::Float(f) => f.is_nan(),
+        }
+    }
+
+    /// Returns true if this value is positive infinity or negative infinity and
+    /// false otherwise.
+    ///
+    /// ```
+    /// # use std::f64;
+    /// #
+    /// # use serde_yaml::Number;
+    /// #
+    /// assert!(!Number::from(256.0).is_infinite());
+    ///
+    /// assert!(!Number::from(f64::NAN).is_infinite());
+    ///
+    /// assert!(Number::from(f64::INFINITY).is_infinite());
+    ///
+    /// assert!(Number::from(f64::NEG_INFINITY).is_infinite());
+    ///
+    /// assert!(!Number::from(1).is_infinite());
+    /// ```
+    #[inline]
+    pub fn is_infinite(&self) -> bool {
+        match self.n {
+            N::PosInt(_) | N::NegInt(_) => false,
+            N::Float(f) => f.is_infinite(),
+        }
+    }
+
+    /// Returns true if this number is neither infinite nor NaN.
+    ///
+    /// ```
+    /// # use std::f64;
+    /// #
+    /// # use serde_yaml::Number;
+    /// #
+    /// assert!(Number::from(256.0).is_finite());
+    ///
+    /// assert!(!Number::from(f64::NAN).is_finite());
+    ///
+    /// assert!(!Number::from(f64::INFINITY).is_finite());
+    ///
+    /// assert!(!Number::from(f64::NEG_INFINITY).is_finite());
+    ///
+    /// assert!(Number::from(1).is_finite());
+    /// ```
+    #[inline]
+    pub fn is_finite(&self) -> bool {
+        match self.n {
+            N::PosInt(_) | N::NegInt(_) => true,
+            N::Float(f) => f.is_finite(),
+        }
+    }
+}
+
+impl fmt::Display for Number {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self.n {
+            N::PosInt(i) => Display::fmt(&i, formatter),
+            N::NegInt(i) => Display::fmt(&i, formatter),
+            N::Float(f) if f.is_nan() => formatter.write_str(".nan"),
+            N::Float(f) if f.is_infinite() => {
+                if f.is_sign_negative() {
+                    formatter.write_str("-.inf")
+                } else {
+                    formatter.write_str(".inf")
+                }
+            }
+            N::Float(f) => Display::fmt(&f, formatter),
+        }
+    }
+}
+
+impl Debug for Number {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.n, formatter)
+    }
+}
+
+impl PartialEq for N {
+    fn eq(&self, other: &N) -> bool {
+        match (*self, *other) {
+            (N::PosInt(a), N::PosInt(b)) => a == b,
+            (N::NegInt(a), N::NegInt(b)) => a == b,
+            (N::Float(a), N::Float(b)) => {
+                if a.is_nan() && b.is_nan() {
+                    // YAML only has one NaN;
+                    // the bit representation isn't preserved
+                    true
+                } else {
+                    a == b
+                }
+            }
+            _ => false,
+        }
+    }
+}
+
+impl PartialOrd for N {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (*self, *other) {
+            (N::Float(a), N::Float(b)) => {
+                if a.is_nan() && b.is_nan() {
+                    // YAML only has one NaN
+                    Some(Ordering::Equal)
+                } else {
+                    a.partial_cmp(&b)
+                }
+            }
+            _ => Some(self.total_cmp(other)),
+        }
+    }
+}
+
+impl N {
+    fn total_cmp(&self, other: &Self) -> Ordering {
+        match (*self, *other) {
+            (N::PosInt(a), N::PosInt(b)) => a.cmp(&b),
+            (N::NegInt(a), N::NegInt(b)) => a.cmp(&b),
+            // negint is always less than zero
+            (N::NegInt(_), N::PosInt(_)) => Ordering::Less,
+            (N::PosInt(_), N::NegInt(_)) => Ordering::Greater,
+            (N::Float(a), N::Float(b)) => a.partial_cmp(&b).unwrap_or_else(|| {
+                // arbitrarily sort the NaN last
+                if !a.is_nan() {
+                    Ordering::Less
+                } else if !b.is_nan() {
+                    Ordering::Greater
+                } else {
+                    Ordering::Equal
+                }
+            }),
+            // arbitrarily sort integers below floats
+            // FIXME: maybe something more sensible?
+            (_, N::Float(_)) => Ordering::Less,
+            (N::Float(_), _) => Ordering::Greater,
+        }
+    }
+}
+
+impl Number {
+    pub(crate) fn total_cmp(&self, other: &Self) -> Ordering {
+        self.n.total_cmp(&other.n)
+    }
+}
+
+impl Serialize for Number {
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self.n {
+            N::PosInt(i) => serializer.serialize_u64(i),
+            N::NegInt(i) => serializer.serialize_i64(i),
+            N::Float(f) => serializer.serialize_f64(f),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Number {
+    #[inline]
+    fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct NumberVisitor;
+
+        impl<'de> Visitor<'de> for NumberVisitor {
+            type Value = Number;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a number")
+            }
+
+            #[inline]
+            fn visit_i64<E>(self, value: i64) -> Result<Number, E> {
+                Ok(value.into())
+            }
+
+            #[inline]
+            fn visit_u64<E>(self, value: u64) -> Result<Number, E> {
+                Ok(value.into())
+            }
+
+            #[inline]
+            fn visit_f64<E>(self, value: f64) -> Result<Number, E> {
+                Ok(value.into())
+            }
+        }
+
+        deserializer.deserialize_any(NumberVisitor)
+    }
+}
+
+impl<'de> Deserializer<'de> for Number {
+    type Error = Error;
+
+    #[inline]
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self.n {
+            N::PosInt(i) => visitor.visit_u64(i),
+            N::NegInt(i) => visitor.visit_i64(i),
+            N::Float(f) => visitor.visit_f64(f),
+        }
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+impl<'de, 'a> Deserializer<'de> for &'a Number {
+    type Error = Error;
+
+    #[inline]
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self.n {
+            N::PosInt(i) => visitor.visit_u64(i),
+            N::NegInt(i) => visitor.visit_i64(i),
+            N::Float(f) => visitor.visit_f64(f),
+        }
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+macro_rules! from_signed {
+    ($($signed_ty:ident)*) => {
+        $(
+            impl From<$signed_ty> for Number {
+                #[inline]
+                #[allow(clippy::cast_sign_loss)]
+                fn from(i: $signed_ty) -> Self {
+                    if i < 0 {
+                        Number { n: N::NegInt(i as i64) }
+                    } else {
+                        Number { n: N::PosInt(i as u64) }
+                    }
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! from_unsigned {
+    ($($unsigned_ty:ident)*) => {
+        $(
+            impl From<$unsigned_ty> for Number {
+                #[inline]
+                fn from(u: $unsigned_ty) -> Self {
+                    Number { n: N::PosInt(u as u64) }
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! from_float {
+    ($($float_ty:ident)*) => {
+        $(
+            impl From<$float_ty> for Number {
+                #[inline]
+                fn from(f: $float_ty) -> Self {
+                    Number { n: N::Float(f as f64) }
+                }
+            }
+        )*
+    }
+}
+
+from_signed!(i8 i16 i32 i64 isize);
+from_unsigned!(u8 u16 u32 u64 usize);
+from_float!(f32 f64);
+
+// This is fine, because we don't _really_ implement hash for floats
+// all other hash functions should work as expected
+#[allow(clippy::derive_hash_xor_eq)]
+impl Hash for Number {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self.n {
+            N::Float(_) => {
+                // you should feel bad for using f64 as a map key
+                3.hash(state);
+            }
+            N::PosInt(u) => u.hash(state),
+            N::NegInt(i) => i.hash(state),
+        }
+    }
+}
+
+pub(crate) fn unexpected(number: &Number) -> Unexpected {
+    match number.n {
+        N::PosInt(u) => Unexpected::Unsigned(u),
+        N::NegInt(i) => Unexpected::Signed(i),
+        N::Float(f) => Unexpected::Float(f),
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/path.rs b/third_party/rust/serde_yaml/src/path.rs
new file mode 100644
index 0000000000..095add017b
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/path.rs
@@ -0,0 +1,34 @@
+use std::fmt::{self, Display};
+
+/// Path to the current value in the input, like `dependencies.serde.typo1`.
+#[derive(Copy, Clone)]
+pub enum Path<'a> {
+    Root,
+    Seq { parent: &'a Path<'a>, index: usize },
+    Map { parent: &'a Path<'a>, key: &'a str },
+    Alias { parent: &'a Path<'a> },
+    Unknown { parent: &'a Path<'a> },
+}
+
+impl<'a> Display for Path<'a> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        struct Parent<'a>(&'a Path<'a>);
+
+        impl<'a> Display for Parent<'a> {
+            fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+                match self.0 {
+                    Path::Root => Ok(()),
+                    path => write!(formatter, "{}.", path),
+                }
+            }
+        }
+
+        match self {
+            Path::Root => formatter.write_str("."),
+            Path::Seq { parent, index } => write!(formatter, "{}[{}]", parent, index),
+            Path::Map { parent, key } => write!(formatter, "{}{}", Parent(parent), key),
+            Path::Alias { parent } => write!(formatter, "{}", parent),
+            Path::Unknown { parent } => write!(formatter, "{}?", Parent(parent)),
+        }
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/ser.rs b/third_party/rust/serde_yaml/src/ser.rs
new file mode 100644
index 0000000000..6ce5995dff
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/ser.rs
@@ -0,0 +1,887 @@
+//! YAML Serialization
+//!
+//! This module provides YAML serialization with the type `Serializer`.
+
+use crate::{error, Error, Result};
+use serde::ser;
+use std::{fmt, io, num, str};
+use yaml_rust::{yaml, Yaml, YamlEmitter};
+
+/// A structure for serializing Rust values into YAML.
+///
+/// # Example
+///
+/// ```
+/// use anyhow::Result;
+/// use serde::Serialize;
+/// use std::collections::BTreeMap;
+///
+/// fn main() -> Result<()> {
+///     let mut buffer = Vec::new();
+///     let mut ser = serde_yaml::Serializer::new(&mut buffer);
+///
+///     let mut object = BTreeMap::new();
+///     object.insert("k", 107);
+///     object.serialize(&mut ser)?;
+///
+///     object.insert("J", 74);
+///     object.serialize(&mut ser)?;
+///
+///     assert_eq!(buffer, b"---\nk: 107\n...\n---\nJ: 74\nk: 107\n");
+///     Ok(())
+/// }
+/// ```
+pub struct Serializer<W> {
+    documents: usize,
+    writer: W,
+}
+
+impl<W> Serializer<W>
+where
+    W: io::Write,
+{
+    /// Creates a new YAML serializer.
+    pub fn new(writer: W) -> Self {
+        Serializer {
+            documents: 0,
+            writer,
+        }
+    }
+
+    /// Calls [`.flush()`](io::Write::flush) on the underlying `io::Write`
+    /// object.
+    pub fn flush(&mut self) -> io::Result<()> {
+        self.writer.flush()
+    }
+
+    /// Unwrap the underlying `io::Write` object from the `Serializer`.
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+
+    fn write(&mut self, doc: Yaml) -> Result<()> {
+        if self.documents > 0 {
+            self.writer.write_all(b"...\n").map_err(error::io)?;
+        }
+        self.documents += 1;
+        let mut writer_adapter = FmtToIoWriter {
+            writer: &mut self.writer,
+        };
+        YamlEmitter::new(&mut writer_adapter)
+            .dump(&doc)
+            .map_err(error::emitter)?;
+        writer_adapter.writer.write_all(b"\n").map_err(error::io)?;
+        Ok(())
+    }
+}
+
+impl<'a, W> ser::Serializer for &'a mut Serializer<W>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    type SerializeSeq = ThenWrite<'a, W, SerializeArray>;
+    type SerializeTuple = ThenWrite<'a, W, SerializeArray>;
+    type SerializeTupleStruct = ThenWrite<'a, W, SerializeArray>;
+    type SerializeTupleVariant = ThenWrite<'a, W, SerializeTupleVariant>;
+    type SerializeMap = ThenWrite<'a, W, SerializeMap>;
+    type SerializeStruct = ThenWrite<'a, W, SerializeStruct>;
+    type SerializeStructVariant = ThenWrite<'a, W, SerializeStructVariant>;
+
+    fn serialize_bool(self, v: bool) -> Result<()> {
+        let doc = SerializerToYaml.serialize_bool(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<()> {
+        let doc = SerializerToYaml.serialize_i8(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<()> {
+        let doc = SerializerToYaml.serialize_i16(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<()> {
+        let doc = SerializerToYaml.serialize_i32(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<()> {
+        let doc = SerializerToYaml.serialize_i64(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_i128(self, v: i128) -> Result<()> {
+        let doc = SerializerToYaml.serialize_i128(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<()> {
+        let doc = SerializerToYaml.serialize_u8(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<()> {
+        let doc = SerializerToYaml.serialize_u16(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<()> {
+        let doc = SerializerToYaml.serialize_u32(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<()> {
+        let doc = SerializerToYaml.serialize_u64(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_u128(self, v: u128) -> Result<()> {
+        let doc = SerializerToYaml.serialize_u128(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<()> {
+        let doc = SerializerToYaml.serialize_f32(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<()> {
+        let doc = SerializerToYaml.serialize_f64(v)?;
+        self.write(doc)
+    }
+
+    fn serialize_char(self, value: char) -> Result<()> {
+        let doc = SerializerToYaml.serialize_char(value)?;
+        self.write(doc)
+    }
+
+    fn serialize_str(self, value: &str) -> Result<()> {
+        let doc = SerializerToYaml.serialize_str(value)?;
+        self.write(doc)
+    }
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
+        let doc = SerializerToYaml.serialize_bytes(value)?;
+        self.write(doc)
+    }
+
+    fn serialize_unit(self) -> Result<()> {
+        let doc = SerializerToYaml.serialize_unit()?;
+        self.write(doc)
+    }
+
+    fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
+        let doc = SerializerToYaml.serialize_unit_struct(name)?;
+        self.write(doc)
+    }
+
+    fn serialize_unit_variant(
+        self,
+        name: &'static str,
+        variant_index: u32,
+        variant: &'static str,
+    ) -> Result<()> {
+        let doc = SerializerToYaml.serialize_unit_variant(name, variant_index, variant)?;
+        self.write(doc)
+    }
+
+    fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        let doc = SerializerToYaml.serialize_newtype_struct(name, value)?;
+        self.write(doc)
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        name: &'static str,
+        variant_index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        let doc =
+            SerializerToYaml.serialize_newtype_variant(name, variant_index, variant, value)?;
+        self.write(doc)
+    }
+
+    fn serialize_none(self) -> Result<()> {
+        let doc = SerializerToYaml.serialize_none()?;
+        self.write(doc)
+    }
+
+    fn serialize_some<V>(self, value: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        let doc = SerializerToYaml.serialize_some(value)?;
+        self.write(doc)
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+        let delegate = SerializerToYaml.serialize_seq(len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
+        let delegate = SerializerToYaml.serialize_tuple(len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct> {
+        let delegate = SerializerToYaml.serialize_tuple_struct(name, len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        enm: &'static str,
+        idx: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
+        let delegate = SerializerToYaml.serialize_tuple_variant(enm, idx, variant, len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
+        let delegate = SerializerToYaml.serialize_map(len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+        let delegate = SerializerToYaml.serialize_struct(name, len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        enm: &'static str,
+        idx: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
+        let delegate = SerializerToYaml.serialize_struct_variant(enm, idx, variant, len)?;
+        Ok(ThenWrite::new(self, delegate))
+    }
+}
+
+pub struct ThenWrite<'a, W, D> {
+    serializer: &'a mut Serializer<W>,
+    delegate: D,
+}
+
+impl<'a, W, D> ThenWrite<'a, W, D> {
+    fn new(serializer: &'a mut Serializer<W>, delegate: D) -> Self {
+        ThenWrite {
+            serializer,
+            delegate,
+        }
+    }
+}
+
+impl<'a, W> ser::SerializeSeq for ThenWrite<'a, W, SerializeArray>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_element(elem)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+impl<'a, W> ser::SerializeTuple for ThenWrite<'a, W, SerializeArray>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_element(elem)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+impl<'a, W> ser::SerializeTupleStruct for ThenWrite<'a, W, SerializeArray>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, value: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_field(value)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+impl<'a, W> ser::SerializeTupleVariant for ThenWrite<'a, W, SerializeTupleVariant>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, v: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_field(v)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+impl<'a, W> ser::SerializeMap for ThenWrite<'a, W, SerializeMap>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_key(key)
+    }
+
+    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_value(value)
+    }
+
+    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
+    where
+        K: ?Sized + ser::Serialize,
+        V: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_entry(key, value)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+impl<'a, W> ser::SerializeStruct for ThenWrite<'a, W, SerializeStruct>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_field(key, value)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+impl<'a, W> ser::SerializeStructVariant for ThenWrite<'a, W, SerializeStructVariant>
+where
+    W: io::Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.delegate.serialize_field(field, v)
+    }
+
+    fn end(self) -> Result<()> {
+        let doc = self.delegate.end()?;
+        self.serializer.write(doc)
+    }
+}
+
+pub struct SerializerToYaml;
+
+impl ser::Serializer for SerializerToYaml {
+    type Ok = Yaml;
+    type Error = Error;
+
+    type SerializeSeq = SerializeArray;
+    type SerializeTuple = SerializeArray;
+    type SerializeTupleStruct = SerializeArray;
+    type SerializeTupleVariant = SerializeTupleVariant;
+    type SerializeMap = SerializeMap;
+    type SerializeStruct = SerializeStruct;
+    type SerializeStructVariant = SerializeStructVariant;
+
+    fn serialize_bool(self, v: bool) -> Result<Yaml> {
+        Ok(Yaml::Boolean(v))
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<Yaml> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<Yaml> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<Yaml> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<Yaml> {
+        Ok(Yaml::Integer(v))
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn serialize_i128(self, v: i128) -> Result<Yaml> {
+        if v <= i64::max_value() as i128 && v >= i64::min_value() as i128 {
+            self.serialize_i64(v as i64)
+        } else {
+            Ok(Yaml::Real(v.to_string()))
+        }
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<Yaml> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<Yaml> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<Yaml> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<Yaml> {
+        if v <= i64::max_value() as u64 {
+            self.serialize_i64(v as i64)
+        } else {
+            Ok(Yaml::Real(v.to_string()))
+        }
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn serialize_u128(self, v: u128) -> Result<Yaml> {
+        if v <= i64::max_value() as u128 {
+            self.serialize_i64(v as i64)
+        } else {
+            Ok(Yaml::Real(v.to_string()))
+        }
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<Yaml> {
+        Ok(Yaml::Real(match v.classify() {
+            num::FpCategory::Infinite if v.is_sign_positive() => ".inf".into(),
+            num::FpCategory::Infinite => "-.inf".into(),
+            num::FpCategory::Nan => ".nan".into(),
+            _ => ryu::Buffer::new().format_finite(v).into(),
+        }))
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<Yaml> {
+        Ok(Yaml::Real(match v.classify() {
+            num::FpCategory::Infinite if v.is_sign_positive() => ".inf".into(),
+            num::FpCategory::Infinite => "-.inf".into(),
+            num::FpCategory::Nan => ".nan".into(),
+            _ => ryu::Buffer::new().format_finite(v).into(),
+        }))
+    }
+
+    fn serialize_char(self, value: char) -> Result<Yaml> {
+        Ok(Yaml::String(value.to_string()))
+    }
+
+    fn serialize_str(self, value: &str) -> Result<Yaml> {
+        Ok(Yaml::String(value.to_owned()))
+    }
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<Yaml> {
+        let vec = value.iter().map(|&b| Yaml::Integer(b as i64)).collect();
+        Ok(Yaml::Array(vec))
+    }
+
+    fn serialize_unit(self) -> Result<Yaml> {
+        Ok(Yaml::Null)
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Yaml> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &str,
+        _variant_index: u32,
+        variant: &str,
+    ) -> Result<Yaml> {
+        Ok(Yaml::String(variant.to_owned()))
+    }
+
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Yaml>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &str,
+        _variant_index: u32,
+        variant: &str,
+        value: &T,
+    ) -> Result<Yaml>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        Ok(singleton_hash(to_yaml(variant)?, to_yaml(value)?))
+    }
+
+    fn serialize_none(self) -> Result<Yaml> {
+        self.serialize_unit()
+    }
+
+    fn serialize_some<V>(self, value: &V) -> Result<Yaml>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<SerializeArray> {
+        let array = match len {
+            None => yaml::Array::new(),
+            Some(len) => yaml::Array::with_capacity(len),
+        };
+        Ok(SerializeArray { array })
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<SerializeArray> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<SerializeArray> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _enum: &'static str,
+        _idx: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<SerializeTupleVariant> {
+        Ok(SerializeTupleVariant {
+            name: variant,
+            array: yaml::Array::with_capacity(len),
+        })
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<SerializeMap> {
+        Ok(SerializeMap {
+            hash: yaml::Hash::new(),
+            next_key: None,
+        })
+    }
+
+    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<SerializeStruct> {
+        Ok(SerializeStruct {
+            hash: yaml::Hash::new(),
+        })
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _enum: &'static str,
+        _idx: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<SerializeStructVariant> {
+        Ok(SerializeStructVariant {
+            name: variant,
+            hash: yaml::Hash::new(),
+        })
+    }
+}
+
+#[doc(hidden)]
+pub struct SerializeArray {
+    array: yaml::Array,
+}
+
+#[doc(hidden)]
+pub struct SerializeTupleVariant {
+    name: &'static str,
+    array: yaml::Array,
+}
+
+#[doc(hidden)]
+pub struct SerializeMap {
+    hash: yaml::Hash,
+    next_key: Option<yaml::Yaml>,
+}
+
+#[doc(hidden)]
+pub struct SerializeStruct {
+    hash: yaml::Hash,
+}
+
+#[doc(hidden)]
+pub struct SerializeStructVariant {
+    name: &'static str,
+    hash: yaml::Hash,
+}
+
+impl ser::SerializeSeq for SerializeArray {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        self.array.push(to_yaml(elem)?);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Yaml> {
+        Ok(Yaml::Array(self.array))
+    }
+}
+
+impl ser::SerializeTuple for SerializeArray {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        ser::SerializeSeq::serialize_element(self, elem)
+    }
+
+    fn end(self) -> Result<Yaml> {
+        ser::SerializeSeq::end(self)
+    }
+}
+
+impl ser::SerializeTupleStruct for SerializeArray {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, value: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    fn end(self) -> Result<Yaml> {
+        ser::SerializeSeq::end(self)
+    }
+}
+
+impl ser::SerializeTupleVariant for SerializeTupleVariant {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, v: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.array.push(to_yaml(v)?);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Yaml> {
+        Ok(singleton_hash(to_yaml(self.name)?, Yaml::Array(self.array)))
+    }
+}
+
+impl ser::SerializeMap for SerializeMap {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        self.next_key = Some(to_yaml(key)?);
+        Ok(())
+    }
+
+    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        match self.next_key.take() {
+            Some(key) => self.hash.insert(key, to_yaml(value)?),
+            None => panic!("serialize_value called before serialize_key"),
+        };
+        Ok(())
+    }
+
+    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
+    where
+        K: ?Sized + ser::Serialize,
+        V: ?Sized + ser::Serialize,
+    {
+        self.hash.insert(to_yaml(key)?, to_yaml(value)?);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Yaml> {
+        Ok(Yaml::Hash(self.hash))
+    }
+}
+
+impl ser::SerializeStruct for SerializeStruct {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.hash.insert(to_yaml(key)?, to_yaml(value)?);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Yaml> {
+        Ok(Yaml::Hash(self.hash))
+    }
+}
+
+impl ser::SerializeStructVariant for SerializeStructVariant {
+    type Ok = yaml::Yaml;
+    type Error = Error;
+
+    fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
+    where
+        V: ?Sized + ser::Serialize,
+    {
+        self.hash.insert(to_yaml(field)?, to_yaml(v)?);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Yaml> {
+        Ok(singleton_hash(to_yaml(self.name)?, Yaml::Hash(self.hash)))
+    }
+}
+
+/// Serialize the given data structure as YAML into the IO stream.
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// return an error.
+pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
+where
+    W: io::Write,
+    T: ?Sized + ser::Serialize,
+{
+    value.serialize(&mut Serializer::new(writer))
+}
+
+/// Serialize the given data structure as a YAML byte vector.
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// return an error.
+pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
+where
+    T: ?Sized + ser::Serialize,
+{
+    let mut vec = Vec::with_capacity(128);
+    to_writer(&mut vec, value)?;
+    Ok(vec)
+}
+
+/// Serialize the given data structure as a String of YAML.
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// return an error.
+pub fn to_string<T>(value: &T) -> Result<String>
+where
+    T: ?Sized + ser::Serialize,
+{
+    String::from_utf8(to_vec(value)?).map_err(error::string_utf8)
+}
+
+/// The yaml-rust library uses `fmt::Write` intead of `io::Write` so this is a
+/// simple adapter.
+struct FmtToIoWriter<W> {
+    writer: W,
+}
+
+impl<W> fmt::Write for FmtToIoWriter<W>
+where
+    W: io::Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        if self.writer.write_all(s.as_bytes()).is_err() {
+            return Err(fmt::Error);
+        }
+        Ok(())
+    }
+}
+
+fn to_yaml<T>(elem: T) -> Result<Yaml>
+where
+    T: ser::Serialize,
+{
+    elem.serialize(SerializerToYaml)
+}
+
+fn singleton_hash(k: Yaml, v: Yaml) -> Yaml {
+    let mut hash = yaml::Hash::new();
+    hash.insert(k, v);
+    Yaml::Hash(hash)
+}
diff --git a/third_party/rust/serde_yaml/src/value/de.rs b/third_party/rust/serde_yaml/src/value/de.rs
new file mode 100644
index 0000000000..61e0469693
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/value/de.rs
@@ -0,0 +1,707 @@
+use crate::{number, Error, Mapping, Sequence, Value};
+use serde::de::{
+    self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as SError, Expected,
+    MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor,
+};
+use serde::forward_to_deserialize_any;
+use std::fmt;
+use std::vec;
+
+impl<'de> Deserialize<'de> for Value {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct ValueVisitor;
+
+        impl<'de> Visitor<'de> for ValueVisitor {
+            type Value = Value;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("any YAML value")
+            }
+
+            fn visit_bool<E>(self, b: bool) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::Bool(b))
+            }
+
+            fn visit_i64<E>(self, i: i64) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::Number(i.into()))
+            }
+
+            fn visit_u64<E>(self, u: u64) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::Number(u.into()))
+            }
+
+            fn visit_f64<E>(self, f: f64) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::Number(f.into()))
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::String(s.to_owned()))
+            }
+
+            fn visit_string<E>(self, s: String) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::String(s))
+            }
+
+            fn visit_unit<E>(self) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::Null)
+            }
+
+            fn visit_none<E>(self) -> Result<Value, E>
+            where
+                E: SError,
+            {
+                Ok(Value::Null)
+            }
+
+            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                Deserialize::deserialize(deserializer)
+            }
+
+            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
+            where
+                V: SeqAccess<'de>,
+            {
+                let mut vec = Vec::new();
+
+                while let Some(element) = visitor.next_element()? {
+                    vec.push(element);
+                }
+
+                Ok(Value::Sequence(vec))
+            }
+
+            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                let mut values = Mapping::new();
+
+                while let Some((key, value)) = visitor.next_entry()? {
+                    values.insert(key, value);
+                }
+
+                Ok(Value::Mapping(values))
+            }
+        }
+
+        deserializer.deserialize_any(ValueVisitor)
+    }
+}
+
+impl Value {
+    fn deserialize_number<'de, V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Number(n) => n.deserialize_any(visitor),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+}
+
+fn visit_sequence<'de, V>(sequence: Sequence, visitor: V) -> Result<V::Value, Error>
+where
+    V: Visitor<'de>,
+{
+    let len = sequence.len();
+    let mut deserializer = SeqDeserializer::new(sequence);
+    let seq = visitor.visit_seq(&mut deserializer)?;
+    let remaining = deserializer.iter.len();
+    if remaining == 0 {
+        Ok(seq)
+    } else {
+        Err(Error::invalid_length(len, &"fewer elements in sequence"))
+    }
+}
+
+fn visit_mapping<'de, V>(mapping: Mapping, visitor: V) -> Result<V::Value, Error>
+where
+    V: Visitor<'de>,
+{
+    let len = mapping.len();
+    let mut deserializer = MapDeserializer::new(mapping);
+    let map = visitor.visit_map(&mut deserializer)?;
+    let remaining = deserializer.iter.len();
+    if remaining == 0 {
+        Ok(map)
+    } else {
+        Err(Error::invalid_length(len, &"fewer elements in map"))
+    }
+}
+
+impl<'de> Deserializer<'de> for Value {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Null => visitor.visit_unit(),
+            Value::Bool(v) => visitor.visit_bool(v),
+            Value::Number(n) => n.deserialize_any(visitor),
+            Value::String(v) => visitor.visit_string(v),
+            Value::Sequence(v) => visit_sequence(v, visitor),
+            Value::Mapping(v) => visit_mapping(v, visitor),
+        }
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Bool(v) => visitor.visit_bool(v),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_number(visitor)
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_string(visitor)
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_string(visitor)
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::String(v) => visitor.visit_string(v),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_byte_buf(visitor)
+    }
+
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::String(v) => visitor.visit_string(v),
+            Value::Sequence(v) => visit_sequence(v, visitor),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Null => visitor.visit_none(),
+            _ => visitor.visit_some(self),
+        }
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Null => visitor.visit_unit(),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Sequence(v) => visit_sequence(v, visitor),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _name: &'static str,
+        _len: usize,
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Mapping(v) => visit_mapping(v, visitor),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Sequence(v) => visit_sequence(v, visitor),
+            Value::Mapping(v) => visit_mapping(v, visitor),
+            _ => Err(self.invalid_type(&visitor)),
+        }
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _name: &str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        let (variant, value) = match self {
+            Value::Mapping(value) => {
+                let mut iter = value.into_iter();
+                let (variant, value) = match iter.next() {
+                    Some(v) => v,
+                    None => {
+                        return Err(Error::invalid_value(
+                            Unexpected::Map,
+                            &"map with a single key",
+                        ));
+                    }
+                };
+                // enums are encoded in json as maps with a single key:value pair
+                if iter.next().is_some() {
+                    return Err(Error::invalid_value(
+                        Unexpected::Map,
+                        &"map with a single key",
+                    ));
+                }
+                (variant, Some(value))
+            }
+            Value::String(variant) => (Value::String(variant), None),
+            other => {
+                return Err(Error::invalid_type(other.unexpected(), &"string or map"));
+            }
+        };
+
+        visitor.visit_enum(EnumDeserializer { variant, value })
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_string(visitor)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        drop(self);
+        visitor.visit_unit()
+    }
+}
+
+struct EnumDeserializer {
+    variant: Value,
+    value: Option<Value>,
+}
+
+impl<'de> EnumAccess<'de> for EnumDeserializer {
+    type Error = Error;
+    type Variant = VariantDeserializer;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        let visitor = VariantDeserializer { value: self.value };
+        seed.deserialize(self.variant).map(|v| (v, visitor))
+    }
+}
+
+struct VariantDeserializer {
+    value: Option<Value>,
+}
+
+impl<'de> VariantAccess<'de> for VariantDeserializer {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<(), Error> {
+        match self.value {
+            Some(value) => Deserialize::deserialize(value),
+            None => Ok(()),
+        }
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.value {
+            Some(value) => seed.deserialize(value),
+            None => Err(Error::invalid_type(
+                Unexpected::UnitVariant,
+                &"newtype variant",
+            )),
+        }
+    }
+
+    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self.value {
+            Some(Value::Sequence(v)) => {
+                Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
+            }
+            Some(other) => Err(Error::invalid_type(other.unexpected(), &"tuple variant")),
+            None => Err(Error::invalid_type(
+                Unexpected::UnitVariant,
+                &"tuple variant",
+            )),
+        }
+    }
+
+    fn struct_variant<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        match self.value {
+            Some(Value::Mapping(v)) => {
+                Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
+            }
+            Some(other) => Err(Error::invalid_type(other.unexpected(), &"struct variant")),
+            None => Err(Error::invalid_type(
+                Unexpected::UnitVariant,
+                &"struct variant",
+            )),
+        }
+    }
+}
+
+struct SeqDeserializer {
+    iter: vec::IntoIter<Value>,
+}
+
+impl SeqDeserializer {
+    fn new(vec: Vec<Value>) -> Self {
+        SeqDeserializer {
+            iter: vec.into_iter(),
+        }
+    }
+}
+
+impl<'de> Deserializer<'de> for SeqDeserializer {
+    type Error = Error;
+
+    #[inline]
+    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        let len = self.iter.len();
+        if len == 0 {
+            visitor.visit_unit()
+        } else {
+            let ret = visitor.visit_seq(&mut self)?;
+            let remaining = self.iter.len();
+            if remaining == 0 {
+                Ok(ret)
+            } else {
+                Err(Error::invalid_length(len, &"fewer elements in sequence"))
+            }
+        }
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        drop(self);
+        visitor.visit_unit()
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
+        map struct enum identifier
+    }
+}
+
+impl<'de> SeqAccess<'de> for SeqDeserializer {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.iter.next() {
+            Some(value) => seed.deserialize(value).map(Some),
+            None => Ok(None),
+        }
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        match self.iter.size_hint() {
+            (lower, Some(upper)) if lower == upper => Some(upper),
+            _ => None,
+        }
+    }
+}
+
+struct MapDeserializer {
+    iter: <Mapping as IntoIterator>::IntoIter,
+    value: Option<Value>,
+}
+
+impl MapDeserializer {
+    fn new(map: Mapping) -> Self {
+        MapDeserializer {
+            iter: map.into_iter(),
+            value: None,
+        }
+    }
+}
+
+impl<'de> MapAccess<'de> for MapDeserializer {
+    type Error = Error;
+
+    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                self.value = Some(value);
+                seed.deserialize(key).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.value.take() {
+            Some(value) => seed.deserialize(value),
+            None => panic!("visit_value called before visit_key"),
+        }
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        match self.iter.size_hint() {
+            (lower, Some(upper)) if lower == upper => Some(upper),
+            _ => None,
+        }
+    }
+}
+
+impl<'de> Deserializer<'de> for MapDeserializer {
+    type Error = Error;
+
+    #[inline]
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(self)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
+    where
+        V: Visitor<'de>,
+    {
+        drop(self);
+        visitor.visit_unit()
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
+        map struct enum identifier
+    }
+}
+
+impl Value {
+    #[cold]
+    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
+    where
+        E: de::Error,
+    {
+        de::Error::invalid_type(self.unexpected(), exp)
+    }
+
+    #[cold]
+    fn unexpected(&self) -> Unexpected {
+        match self {
+            Value::Null => Unexpected::Unit,
+            Value::Bool(b) => Unexpected::Bool(*b),
+            Value::Number(n) => number::unexpected(n),
+            Value::String(s) => Unexpected::Str(s),
+            Value::Sequence(_) => Unexpected::Seq,
+            Value::Mapping(_) => Unexpected::Map,
+        }
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/value/from.rs b/third_party/rust/serde_yaml/src/value/from.rs
new file mode 100644
index 0000000000..c02855d3b1
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/value/from.rs
@@ -0,0 +1,180 @@
+use crate::{Mapping, Value};
+
+// Implement a bunch of conversion to make it easier to create YAML values
+// on the fly.
+
+macro_rules! from_number {
+    ($($ty:ident)*) => {
+        $(
+            impl From<$ty> for Value {
+                fn from(n: $ty) -> Self {
+                    Value::Number(n.into())
+                }
+            }
+        )*
+    };
+}
+
+from_number! {
+    i8 i16 i32 i64 isize
+    u8 u16 u32 u64 usize
+    f32 f64
+}
+
+impl From<bool> for Value {
+    /// Convert boolean to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let b = false;
+    /// let x: Value = b.into();
+    /// ```
+    fn from(f: bool) -> Self {
+        Value::Bool(f)
+    }
+}
+
+impl From<String> for Value {
+    /// Convert `String` to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let s: String = "lorem".to_string();
+    /// let x: Value = s.into();
+    /// ```
+    fn from(f: String) -> Self {
+        Value::String(f)
+    }
+}
+
+impl<'a> From<&'a str> for Value {
+    /// Convert string slice to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let s: &str = "lorem";
+    /// let x: Value = s.into();
+    /// ```
+    fn from(f: &str) -> Self {
+        Value::String(f.to_string())
+    }
+}
+
+use std::borrow::Cow;
+
+impl<'a> From<Cow<'a, str>> for Value {
+    /// Convert copy-on-write string to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    /// use std::borrow::Cow;
+    ///
+    /// let s: Cow<str> = Cow::Borrowed("lorem");
+    /// let x: Value = s.into();
+    /// ```
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    /// use std::borrow::Cow;
+    ///
+    /// let s: Cow<str> = Cow::Owned("lorem".to_string());
+    /// let x: Value = s.into();
+    /// ```
+    fn from(f: Cow<'a, str>) -> Self {
+        Value::String(f.to_string())
+    }
+}
+
+impl From<Mapping> for Value {
+    /// Convert map (with string keys) to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::{Mapping, Value};
+    ///
+    /// let mut m = Mapping::new();
+    /// m.insert("Lorem".into(), "ipsum".into());
+    /// let x: Value = m.into();
+    /// ```
+    fn from(f: Mapping) -> Self {
+        Value::Mapping(f)
+    }
+}
+
+impl<T: Into<Value>> From<Vec<T>> for Value {
+    /// Convert a `Vec` to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let v = vec!["lorem", "ipsum", "dolor"];
+    /// let x: Value = v.into();
+    /// ```
+    fn from(f: Vec<T>) -> Self {
+        Value::Sequence(f.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value {
+    /// Convert a slice to `Value`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
+    /// let x: Value = v.into();
+    /// ```
+    fn from(f: &'a [T]) -> Self {
+        Value::Sequence(f.iter().cloned().map(Into::into).collect())
+    }
+}
+
+use std::iter::FromIterator;
+
+impl<T: Into<Value>> FromIterator<T> for Value {
+    /// Convert an iteratable type to a YAML sequence
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let v = std::iter::repeat(42).take(5);
+    /// let x: Value = v.collect();
+    /// ```
+    ///
+    /// ```
+    /// use serde_yaml::Value;
+    ///
+    /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
+    /// let x: Value = v.into_iter().collect();
+    /// ```
+    ///
+    /// ```
+    /// use std::iter::FromIterator;
+    /// use serde_yaml::Value;
+    ///
+    /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
+    /// ```
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let vec = iter.into_iter().map(T::into).collect();
+
+        Value::Sequence(vec)
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/value/index.rs b/third_party/rust/serde_yaml/src/value/index.rs
new file mode 100644
index 0000000000..b5f5e90160
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/value/index.rs
@@ -0,0 +1,260 @@
+use crate::{Mapping, Value};
+use std::fmt;
+use std::ops;
+
+/// A type that can be used to index into a `serde_yaml::Value`. See the `get`
+/// and `get_mut` methods of `Value`.
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `serde_yaml`.
+pub trait Index: private::Sealed {
+    /// Return None if the key is not already in the sequence or object.
+    #[doc(hidden)]
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;
+
+    /// Return None if the key is not already in the sequence or object.
+    #[doc(hidden)]
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
+
+    /// Panic if sequence index out of bounds. If key is not already in the object,
+    /// insert it with a value of null. Panic if Value is a type that cannot be
+    /// indexed into, except if Value is null then it can be treated as an empty
+    /// object.
+    #[doc(hidden)]
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
+}
+
+impl Index for usize {
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+        match v {
+            Value::Sequence(vec) => vec.get(*self),
+            Value::Mapping(vec) => vec.get(&Value::Number((*self).into())),
+            _ => None,
+        }
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        match v {
+            Value::Sequence(vec) => vec.get_mut(*self),
+            Value::Mapping(vec) => vec.get_mut(&Value::Number((*self).into())),
+            _ => None,
+        }
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        match v {
+            Value::Sequence(vec) => {
+                let len = vec.len();
+                vec.get_mut(*self).unwrap_or_else(|| {
+                    panic!(
+                        "cannot access index {} of YAML sequence of length {}",
+                        self, len
+                    )
+                })
+            }
+            Value::Mapping(map) => {
+                let n = Value::Number((*self).into());
+                // TODO: use entry() once LinkedHashMap supports entry()
+                // https://github.com/contain-rs/linked-hash-map/issues/5
+                if !map.contains_key(&n) {
+                    map.insert(n.clone(), Value::Null);
+                }
+                map.get_mut(&n).unwrap()
+            }
+            _ => panic!("cannot access index {} of YAML {}", self, Type(v)),
+        }
+    }
+}
+
+impl Index for Value {
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+        match v {
+            Value::Mapping(map) => map.get(self),
+            _ => None,
+        }
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        match v {
+            Value::Mapping(map) => map.get_mut(self),
+            _ => None,
+        }
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        if let Value::Null = *v {
+            let mut map = Mapping::new();
+            map.insert(self.clone(), Value::Null);
+            *v = Value::Mapping(map);
+        }
+        match v {
+            Value::Mapping(map) => {
+                // TODO: use entry() once LinkedHashMap supports entry()
+                // https://github.com/contain-rs/linked-hash-map/issues/5
+                if !map.contains_key(self) {
+                    map.insert(self.clone(), Value::Null);
+                }
+                map.get_mut(self).unwrap()
+            }
+            _ => panic!("cannot access key {:?} in YAML {}", self, Type(v)),
+        }
+    }
+}
+
+impl Index for str {
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+        Value::String(self.into()).index_into(v)
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        Value::String(self.into()).index_into_mut(v)
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        Value::String(self.into()).index_or_insert(v)
+    }
+}
+
+impl Index for String {
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+        Value::String(self.clone()).index_into(v)
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        Value::String(self.clone()).index_into_mut(v)
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        Value::String(self.clone()).index_or_insert(v)
+    }
+}
+
+impl<'a, T> Index for &'a T
+where
+    T: ?Sized + Index,
+{
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+        (**self).index_into(v)
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        (**self).index_into_mut(v)
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        (**self).index_or_insert(v)
+    }
+}
+
+// Prevent users from implementing the Index trait.
+mod private {
+    pub trait Sealed {}
+    impl Sealed for usize {}
+    impl Sealed for str {}
+    impl Sealed for String {}
+    impl Sealed for super::Value {}
+    impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}
+}
+
+/// Used in panic messages.
+struct Type<'a>(&'a Value);
+
+impl<'a> fmt::Display for Type<'a> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self.0 {
+            Value::Null => formatter.write_str("null"),
+            Value::Bool(_) => formatter.write_str("boolean"),
+            Value::Number(_) => formatter.write_str("number"),
+            Value::String(_) => formatter.write_str("string"),
+            Value::Sequence(_) => formatter.write_str("sequence"),
+            Value::Mapping(_) => formatter.write_str("mapping"),
+        }
+    }
+}
+
+// The usual semantics of Index is to panic on invalid indexing.
+//
+// That said, the usual semantics are for things like `Vec` and `BTreeMap` which
+// have different use cases than Value. If you are working with a Vec, you know
+// that you are working with a Vec and you can get the len of the Vec and make
+// sure your indices are within bounds. The Value use cases are more
+// loosey-goosey. You got some YAML from an endpoint and you want to pull values
+// out of it. Outside of this Index impl, you already have the option of using
+// `value.as_sequence()` and working with the Vec directly, or matching on
+// `Value::Sequence` and getting the Vec directly. The Index impl means you can
+// skip that and index directly into the thing using a concise syntax. You don't
+// have to check the type, you don't have to check the len, it is all about what
+// you expect the Value to look like.
+//
+// Basically the use cases that would be well served by panicking here are
+// better served by using one of the other approaches: `get` and `get_mut`,
+// `as_sequence`, or match. The value of this impl is that it adds a way of
+// working with Value that is not well served by the existing approaches:
+// concise and careless and sometimes that is exactly what you want.
+impl<I> ops::Index<I> for Value
+where
+    I: Index,
+{
+    type Output = Value;
+
+    /// Index into a `serde_yaml::Value` using the syntax `value[0]` or
+    /// `value["k"]`.
+    ///
+    /// Returns `Value::Null` if the type of `self` does not match the type of
+    /// the index, for example if the index is a string and `self` is a sequence
+    /// or a number. Also returns `Value::Null` if the given key does not exist
+    /// in the map or the given index is not within the bounds of the sequence.
+    ///
+    /// For retrieving deeply nested values, you should have a look at the
+    /// `Value::pointer` method.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let data = yaml(r#"{ x: { y: [z, zz] } }"#);
+    ///
+    /// assert_eq!(data["x"]["y"], yaml(r#"["z", "zz"]"#));
+    /// assert_eq!(data["x"]["y"][0], yaml(r#""z""#));
+    ///
+    /// assert_eq!(data["a"], yaml(r#"null"#)); // returns null for undefined values
+    /// assert_eq!(data["a"]["b"], yaml(r#"null"#)); // does not panic
+    /// ```
+    fn index(&self, index: I) -> &Value {
+        static NULL: Value = Value::Null;
+        index.index_into(self).unwrap_or(&NULL)
+    }
+}
+
+impl<I> ops::IndexMut<I> for Value
+where
+    I: Index,
+{
+    /// Write into a `serde_yaml::Value` using the syntax `value[0] = ...` or
+    /// `value["k"] = ...`.
+    ///
+    /// If the index is a number, the value must be a sequence of length bigger
+    /// than the index. Indexing into a value that is not a sequence or a
+    /// sequence that is too small will panic.
+    ///
+    /// If the index is a string, the value must be an object or null which is
+    /// treated like an empty object. If the key is not already present in the
+    /// object, it will be inserted with a value of null. Indexing into a value
+    /// that is neither an object nor null will panic.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let mut data = yaml(r#"{x: 0}"#);
+    ///
+    /// // replace an existing key
+    /// data["x"] = yaml(r#"1"#);
+    ///
+    /// // insert a new key
+    /// data["y"] = yaml(r#"[false, false, false]"#);
+    ///
+    /// // replace a value in a sequence
+    /// data["y"][0] = yaml(r#"true"#);
+    ///
+    /// // inserted a deeply nested key
+    /// data["a"]["b"]["c"]["d"] = yaml(r#"true"#);
+    ///
+    /// println!("{:?}", data);
+    /// ```
+    fn index_mut(&mut self, index: I) -> &mut Value {
+        index.index_or_insert(self)
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/value/mod.rs b/third_party/rust/serde_yaml/src/value/mod.rs
new file mode 100644
index 0000000000..a71091bffb
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/value/mod.rs
@@ -0,0 +1,648 @@
+mod de;
+mod from;
+mod index;
+mod partial_eq;
+mod ser;
+
+use crate::ser::SerializerToYaml;
+use crate::{Error, Mapping};
+use serde::de::{Deserialize, DeserializeOwned, IntoDeserializer};
+use serde::Serialize;
+use std::f64;
+use std::hash::{Hash, Hasher};
+use std::str::FromStr;
+use yaml_rust::Yaml;
+
+pub use self::index::Index;
+pub use crate::number::Number;
+
+/// Represents any valid YAML value.
+#[derive(Clone, PartialOrd, Debug)]
+pub enum Value {
+    /// Represents a YAML null value.
+    Null,
+    /// Represents a YAML boolean.
+    Bool(bool),
+    /// Represents a YAML numerical value, whether integer or floating point.
+    Number(Number),
+    /// Represents a YAML string.
+    String(String),
+    /// Represents a YAML sequence in which the elements are
+    /// `serde_yaml::Value`.
+    Sequence(Sequence),
+    /// Represents a YAML mapping in which the keys and values are both
+    /// `serde_yaml::Value`.
+    Mapping(Mapping),
+}
+
+/// The default value is `Value::Null`.
+///
+/// This is useful for handling omitted `Value` fields when deserializing.
+///
+/// # Examples
+///
+/// ```
+/// # use serde_derive::Deserialize;
+/// use serde::Deserialize;
+/// use serde_yaml::Value;
+///
+/// #[derive(Deserialize)]
+/// struct Settings {
+///     level: i32,
+///     #[serde(default)]
+///     extras: Value,
+/// }
+///
+/// # fn try_main() -> Result<(), serde_yaml::Error> {
+/// let data = r#" { "level": 42 } "#;
+/// let s: Settings = serde_yaml::from_str(data)?;
+///
+/// assert_eq!(s.level, 42);
+/// assert_eq!(s.extras, Value::Null);
+/// #
+/// #     Ok(())
+/// # }
+/// #
+/// # try_main().unwrap()
+/// ```
+impl Default for Value {
+    fn default() -> Value {
+        Value::Null
+    }
+}
+
+/// A YAML sequence in which the elements are `serde_yaml::Value`.
+pub type Sequence = Vec<Value>;
+
+/// Convert a `T` into `serde_yaml::Value` which is an enum that can represent
+/// any valid YAML data.
+///
+/// This conversion can fail if `T`'s implementation of `Serialize` decides to
+/// return an error.
+///
+/// ```
+/// # use serde_yaml::Value;
+/// let val = serde_yaml::to_value("s").unwrap();
+/// assert_eq!(val, Value::String("s".to_owned()));
+/// ```
+pub fn to_value<T>(value: T) -> Result<Value, Error>
+where
+    T: Serialize,
+{
+    value.serialize(SerializerToYaml).map(yaml_to_value)
+}
+
+/// Interpret a `serde_yaml::Value` as an instance of type `T`.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a YAML map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the YAML map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// ```
+/// # use serde_yaml::Value;
+/// let val = Value::String("foo".to_owned());
+/// let s: String = serde_yaml::from_value(val).unwrap();
+/// assert_eq!("foo", s);
+/// ```
+pub fn from_value<T>(value: Value) -> Result<T, Error>
+where
+    T: DeserializeOwned,
+{
+    Deserialize::deserialize(value)
+}
+
+impl Value {
+    /// Index into a YAML sequence or map. A string index can be used to access
+    /// a value in a map, and a usize index can be used to access an element of
+    /// an sequence.
+    ///
+    /// Returns `None` if the type of `self` does not match the type of the
+    /// index, for example if the index is a string and `self` is a sequence or
+    /// a number. Also returns `None` if the given key does not exist in the map
+    /// or the given index is not within the bounds of the sequence.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// #
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let object: Value = yaml(r#"{ A: 65, B: 66, C: 67 }"#);
+    /// let x = object.get("A").unwrap();
+    /// assert_eq!(x, 65);
+    ///
+    /// let sequence: Value = yaml(r#"[ "A", "B", "C" ]"#);
+    /// let x = sequence.get(2).unwrap();
+    /// assert_eq!(x, &Value::String("C".into()));
+    ///
+    /// assert_eq!(sequence.get("A"), None);
+    /// ```
+    ///
+    /// Square brackets can also be used to index into a value in a more concise
+    /// way. This returns `Value::Null` in cases where `get` would have returned
+    /// `None`.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// #
+    /// # fn yaml(i: &str) -> serde_yaml::Value { serde_yaml::from_str(i).unwrap() }
+    /// #
+    /// let object = yaml(r#"
+    /// ---
+    /// A: [a, á, à]
+    /// B: [b, b́]
+    /// C: [c, ć, ć̣, ḉ]
+    /// 42: true
+    /// "#);
+    /// assert_eq!(object["B"][0], Value::String("b".into()));
+    ///
+    /// assert_eq!(object[Value::String("D".into())], Value::Null);
+    /// assert_eq!(object["D"], Value::Null);
+    /// assert_eq!(object[0]["x"]["y"]["z"], Value::Null);
+    ///
+    /// assert_eq!(object[42], Value::Bool(true));
+    /// ```
+    pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
+        index.index_into(self)
+    }
+
+    /// Index into a YAML sequence or map. A string index can be used to access
+    /// a value in a map, and a usize index can be used to access an element of
+    /// an sequence.
+    ///
+    /// Returns `None` if the type of `self` does not match the type of the
+    /// index, for example if the index is a string and `self` is a sequence or
+    /// a number. Also returns `None` if the given key does not exist in the map
+    /// or the given index is not within the bounds of the sequence.
+    pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
+        index.index_into_mut(self)
+    }
+
+    /// Returns true if the `Value` is a Null. Returns false otherwise.
+    ///
+    /// For any Value on which `is_null` returns true, `as_null` is guaranteed
+    /// to return `Some(())`.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("null").unwrap();
+    /// assert!(v.is_null());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert!(!v.is_null());
+    /// ```
+    pub fn is_null(&self) -> bool {
+        if let Value::Null = *self {
+            true
+        } else {
+            false
+        }
+    }
+
+    /// If the `Value` is a Null, returns (). Returns None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("null").unwrap();
+    /// assert_eq!(v.as_null(), Some(()));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_null(), None);
+    /// ```
+    pub fn as_null(&self) -> Option<()> {
+        match self {
+            Value::Null => Some(()),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
+    ///
+    /// For any Value on which `is_boolean` returns true, `as_bool` is
+    /// guaranteed to return the boolean value.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("true").unwrap();
+    /// assert!(v.is_bool());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("42").unwrap();
+    /// assert!(!v.is_bool());
+    /// ```
+    pub fn is_bool(&self) -> bool {
+        self.as_bool().is_some()
+    }
+
+    /// If the `Value` is a Boolean, returns the associated bool. Returns None
+    /// otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("true").unwrap();
+    /// assert_eq!(v.as_bool(), Some(true));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("42").unwrap();
+    /// assert_eq!(v.as_bool(), None);
+    /// ```
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            Value::Bool(b) => Some(*b),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is a Number. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("5").unwrap();
+    /// assert!(v.is_number());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("true").unwrap();
+    /// assert!(!v.is_number());
+    /// ```
+    pub fn is_number(&self) -> bool {
+        match self {
+            Value::Number(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is an integer between `i64::MIN` and
+    /// `i64::MAX`.
+    ///
+    /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
+    /// return the integer value.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("1337").unwrap();
+    /// assert!(v.is_i64());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("null").unwrap();
+    /// assert!(!v.is_i64());
+    /// ```
+    pub fn is_i64(&self) -> bool {
+        self.as_i64().is_some()
+    }
+
+    /// If the `Value` is an integer, represent it as i64 if possible. Returns
+    /// None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("1337").unwrap();
+    /// assert_eq!(v.as_i64(), Some(1337));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_i64(), None);
+    /// ```
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            Value::Number(n) => n.as_i64(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is an integer between `u64::MIN` and
+    /// `u64::MAX`.
+    ///
+    /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
+    /// return the integer value.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("1337").unwrap();
+    /// assert!(v.is_u64());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("null").unwrap();
+    /// assert!(!v.is_u64());
+    /// ```
+    pub fn is_u64(&self) -> bool {
+        self.as_u64().is_some()
+    }
+
+    /// If the `Value` is an integer, represent it as u64 if possible. Returns
+    /// None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("1337").unwrap();
+    /// assert_eq!(v.as_u64(), Some(1337));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_u64(), None);
+    /// ```
+    pub fn as_u64(&self) -> Option<u64> {
+        match self {
+            Value::Number(n) => n.as_u64(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is a number that can be represented by f64.
+    ///
+    /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to
+    /// return the floating point value.
+    ///
+    /// Currently this function returns true if and only if both `is_i64` and
+    /// `is_u64` return false but this is not a guarantee in the future.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("256.01").unwrap();
+    /// assert!(v.is_f64());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("true").unwrap();
+    /// assert!(!v.is_f64());
+    /// ```
+    pub fn is_f64(&self) -> bool {
+        match self {
+            Value::Number(n) => n.is_f64(),
+            _ => false,
+        }
+    }
+
+    /// If the `Value` is a number, represent it as f64 if possible. Returns
+    /// None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("13.37").unwrap();
+    /// assert_eq!(v.as_f64(), Some(13.37));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_f64(), None);
+    /// ```
+    pub fn as_f64(&self) -> Option<f64> {
+        match self {
+            Value::Number(i) => i.as_f64(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is a String. Returns false otherwise.
+    ///
+    /// For any Value on which `is_string` returns true, `as_str` is guaranteed
+    /// to return the string slice.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("'lorem ipsum'").unwrap();
+    /// assert!(v.is_string());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("42").unwrap();
+    /// assert!(!v.is_string());
+    /// ```
+    pub fn is_string(&self) -> bool {
+        self.as_str().is_some()
+    }
+
+    /// If the `Value` is a String, returns the associated str. Returns None
+    /// otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("'lorem ipsum'").unwrap();
+    /// assert_eq!(v.as_str(), Some("lorem ipsum"));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_str(), None);
+    /// ```
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            Value::String(s) => Some(s),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is a sequence. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("[1, 2, 3]").unwrap();
+    /// assert!(v.is_sequence());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("true").unwrap();
+    /// assert!(!v.is_sequence());
+    /// ```
+    pub fn is_sequence(&self) -> bool {
+        self.as_sequence().is_some()
+    }
+
+    /// If the `Value` is a sequence, return a reference to it if possible.
+    /// Returns None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::{Value, Number};
+    /// let v: Value = serde_yaml::from_str("[1, 2]").unwrap();
+    /// assert_eq!(v.as_sequence(), Some(&vec![Value::Number(Number::from(1)), Value::Number(Number::from(2))]));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_sequence(), None);
+    /// ```
+    pub fn as_sequence(&self) -> Option<&Sequence> {
+        match self {
+            Value::Sequence(seq) => Some(seq),
+            _ => None,
+        }
+    }
+
+    /// If the `Value` is a sequence, return a mutable reference to it if
+    /// possible. Returns None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::{Value, Number};
+    /// let mut v: Value = serde_yaml::from_str("[1]").unwrap();
+    /// let s = v.as_sequence_mut().unwrap();
+    /// s.push(Value::Number(Number::from(2)));
+    /// assert_eq!(s, &vec![Value::Number(Number::from(1)), Value::Number(Number::from(2))]);
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let mut v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_sequence_mut(), None);
+    /// ```
+    pub fn as_sequence_mut(&mut self) -> Option<&mut Sequence> {
+        match self {
+            Value::Sequence(seq) => Some(seq),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Value` is a mapping. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("a: 42").unwrap();
+    /// assert!(v.is_mapping());
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("true").unwrap();
+    /// assert!(!v.is_mapping());
+    /// ```
+    pub fn is_mapping(&self) -> bool {
+        self.as_mapping().is_some()
+    }
+
+    /// If the `Value` is a mapping, return a reference to it if possible.
+    /// Returns None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::{Value, Mapping, Number};
+    /// let v: Value = serde_yaml::from_str("a: 42").unwrap();
+    ///
+    /// let mut expected = Mapping::new();
+    /// expected.insert(Value::String("a".into()),Value::Number(Number::from(42)));
+    ///
+    /// assert_eq!(v.as_mapping(), Some(&expected));
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// let v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_mapping(), None);
+    /// ```
+    pub fn as_mapping(&self) -> Option<&Mapping> {
+        match self {
+            Value::Mapping(map) => Some(map),
+            _ => None,
+        }
+    }
+
+    /// If the `Value` is a mapping, return a reference to it if possible.
+    /// Returns None otherwise.
+    ///
+    /// ```
+    /// # use serde_yaml::{Value, Mapping, Number};
+    /// let mut v: Value = serde_yaml::from_str("a: 42").unwrap();
+    /// let m = v.as_mapping_mut().unwrap();
+    /// m.insert(Value::String("b".into()), Value::Number(Number::from(21)));
+    ///
+    /// let mut expected = Mapping::new();
+    /// expected.insert(Value::String("a".into()), Value::Number(Number::from(42)));
+    /// expected.insert(Value::String("b".into()), Value::Number(Number::from(21)));
+    ///
+    /// assert_eq!(m, &expected);
+    /// ```
+    ///
+    /// ```
+    /// # use serde_yaml::{Value, Mapping};
+    /// let mut v: Value = serde_yaml::from_str("false").unwrap();
+    /// assert_eq!(v.as_mapping_mut(), None);
+    /// ```
+    pub fn as_mapping_mut(&mut self) -> Option<&mut Mapping> {
+        match self {
+            Value::Mapping(map) => Some(map),
+            _ => None,
+        }
+    }
+}
+
+fn yaml_to_value(yaml: Yaml) -> Value {
+    match yaml {
+        Yaml::Real(f) => {
+            if f == ".inf" {
+                Value::Number(f64::INFINITY.into())
+            } else if f == "-.inf" {
+                Value::Number(f64::NEG_INFINITY.into())
+            } else if f == ".nan" {
+                Value::Number(f64::NAN.into())
+            } else if let Ok(n) = u64::from_str(&f) {
+                Value::Number(n.into())
+            } else if let Ok(n) = i64::from_str(&f) {
+                Value::Number(n.into())
+            } else if let Ok(n) = f64::from_str(&f) {
+                Value::Number(n.into())
+            } else {
+                Value::String(f)
+            }
+        }
+        Yaml::Integer(i) => Value::Number(i.into()),
+        Yaml::String(s) => Value::String(s),
+        Yaml::Boolean(b) => Value::Bool(b),
+        Yaml::Array(sequence) => Value::Sequence(sequence.into_iter().map(yaml_to_value).collect()),
+        Yaml::Hash(hash) => Value::Mapping(
+            hash.into_iter()
+                .map(|(k, v)| (yaml_to_value(k), yaml_to_value(v)))
+                .collect(),
+        ),
+        Yaml::Alias(_) => panic!("alias unsupported"),
+        Yaml::Null => Value::Null,
+        Yaml::BadValue => panic!("bad value"),
+    }
+}
+
+impl Eq for Value {}
+
+impl Hash for Value {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            Value::Null => 0.hash(state),
+            Value::Bool(b) => (1, b).hash(state),
+            Value::Number(i) => (2, i).hash(state),
+            Value::String(s) => (3, s).hash(state),
+            Value::Sequence(seq) => (4, seq).hash(state),
+            Value::Mapping(map) => (5, map).hash(state),
+        }
+    }
+}
+
+impl<'de> IntoDeserializer<'de, Error> for Value {
+    type Deserializer = Self;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        self
+    }
+}
diff --git a/third_party/rust/serde_yaml/src/value/partial_eq.rs b/third_party/rust/serde_yaml/src/value/partial_eq.rs
new file mode 100644
index 0000000000..ff9b1f8f8a
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/value/partial_eq.rs
@@ -0,0 +1,149 @@
+use crate::Value;
+
+impl PartialEq for Value {
+    fn eq(&self, other: &Value) -> bool {
+        match (self, other) {
+            (Value::Null, Value::Null) => true,
+            (Value::Bool(a), Value::Bool(b)) => a == b,
+            (Value::Number(a), Value::Number(b)) => a == b,
+            (Value::String(a), Value::String(b)) => a == b,
+            (Value::Sequence(a), Value::Sequence(b)) => a == b,
+            (Value::Mapping(a), Value::Mapping(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<str> for Value {
+    /// Compare `str` with YAML value
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!(Value::String("lorem".into()) == *"lorem");
+    /// ```
+    fn eq(&self, other: &str) -> bool {
+        self.as_str().map_or(false, |s| s == other)
+    }
+}
+
+impl<'a> PartialEq<&'a str> for Value {
+    /// Compare `&str` with YAML value
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!(Value::String("lorem".into()) == "lorem");
+    /// ```
+    fn eq(&self, other: &&str) -> bool {
+        self.as_str().map_or(false, |s| s == *other)
+    }
+}
+
+impl PartialEq<Value> for str {
+    /// Compare YAML value with `str`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!(*"lorem" == Value::String("lorem".into()));
+    /// ```
+    fn eq(&self, other: &Value) -> bool {
+        other.as_str().map_or(false, |s| s == self)
+    }
+}
+
+impl<'a> PartialEq<Value> for &'a str {
+    /// Compare `&str` with YAML value
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!("lorem" == Value::String("lorem".into()));
+    /// ```
+    fn eq(&self, other: &Value) -> bool {
+        other.as_str().map_or(false, |s| s == *self)
+    }
+}
+
+impl PartialEq<String> for Value {
+    /// Compare YAML value with String
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!(Value::String("lorem".into()) == "lorem".to_string());
+    /// ```
+    fn eq(&self, other: &String) -> bool {
+        self.as_str().map_or(false, |s| s == other)
+    }
+}
+
+impl PartialEq<Value> for String {
+    /// Compare `String` with YAML value
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!("lorem".to_string() == Value::String("lorem".into()));
+    /// ```
+    fn eq(&self, other: &Value) -> bool {
+        other.as_str().map_or(false, |s| s == self)
+    }
+}
+
+impl PartialEq<bool> for Value {
+    /// Compare YAML value with bool
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_yaml::Value;
+    /// assert!(Value::Bool(true) == true);
+    /// ```
+    fn eq(&self, other: &bool) -> bool {
+        self.as_bool().map_or(false, |b| b == *other)
+    }
+}
+
+macro_rules! partialeq_numeric {
+    ($([$($ty:ty)*], $conversion:ident, $base:ty)*) => {
+        $($(
+            impl PartialEq<$ty> for Value {
+                fn eq(&self, other: &$ty) -> bool {
+                    self.$conversion().map_or(false, |i| i == (*other as $base))
+                }
+            }
+
+            impl PartialEq<Value> for $ty {
+                fn eq(&self, other: &Value) -> bool {
+                    other.$conversion().map_or(false, |i| i == (*self as $base))
+                }
+            }
+
+            impl<'a> PartialEq<$ty> for &'a Value {
+                fn eq(&self, other: &$ty) -> bool {
+                    self.$conversion().map_or(false, |i| i == (*other as $base))
+                }
+            }
+
+            impl<'a> PartialEq<$ty> for &'a mut Value {
+                fn eq(&self, other: &$ty) -> bool {
+                    self.$conversion().map_or(false, |i| i == (*other as $base))
+                }
+            }
+        )*)*
+    }
+}
+
+partialeq_numeric! {
+    [i8 i16 i32 i64 isize], as_i64, i64
+    [u8 u16 u32 u64 usize], as_u64, u64
+    [f32 f64], as_f64, f64
+}
diff --git a/third_party/rust/serde_yaml/src/value/ser.rs b/third_party/rust/serde_yaml/src/value/ser.rs
new file mode 100644
index 0000000000..f2c4bb438c
--- /dev/null
+++ b/third_party/rust/serde_yaml/src/value/ser.rs
@@ -0,0 +1,25 @@
+use crate::Value;
+use serde::Serialize;
+
+impl Serialize for Value {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Value::Null => serializer.serialize_unit(),
+            Value::Bool(b) => serializer.serialize_bool(*b),
+            Value::Number(n) => n.serialize(serializer),
+            Value::String(s) => serializer.serialize_str(s),
+            Value::Sequence(seq) => seq.serialize(serializer),
+            Value::Mapping(hash) => {
+                use serde::ser::SerializeMap;
+                let mut map = serializer.serialize_map(Some(hash.len()))?;
+                for (k, v) in hash {
+                    map.serialize_entry(k, v)?;
+                }
+                map.end()
+            }
+        }
+    }
+}