chore: checkpoint before Python removal

vendor/serde_json/src/value/from.rs

@@ -0,0 +1,284 @@
+use super::Value;
+use crate::map::Map;
+use crate::number::Number;
+use alloc::borrow::{Cow, ToOwned};
+use alloc::string::String;
+use alloc::vec::Vec;
+
+macro_rules! from_integer {
+    ($($ty:ident)*) => {
+        $(
+            impl From<$ty> for Value {
+                fn from(n: $ty) -> Self {
+                    Value::Number(n.into())
+                }
+            }
+        )*
+    };
+}
+
+from_integer! {
+    i8 i16 i32 i64 isize
+    u8 u16 u32 u64 usize
+}
+
+#[cfg(feature = "arbitrary_precision")]
+from_integer! {
+    i128 u128
+}
+
+impl From<f32> for Value {
+    /// Convert 32-bit floating point number to `Value::Number`, or
+    /// `Value::Null` if infinite or NaN.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let f: f32 = 13.37;
+    /// let x: Value = f.into();
+    /// ```
+    fn from(f: f32) -> Self {
+        Number::from_f32(f).map_or(Value::Null, Value::Number)
+    }
+}
+
+impl From<f64> for Value {
+    /// Convert 64-bit floating point number to `Value::Number`, or
+    /// `Value::Null` if infinite or NaN.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let f: f64 = 13.37;
+    /// let x: Value = f.into();
+    /// ```
+    fn from(f: f64) -> Self {
+        Number::from_f64(f).map_or(Value::Null, Value::Number)
+    }
+}
+
+impl From<bool> for Value {
+    /// Convert boolean to `Value::Bool`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::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::String`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let s: String = "lorem".to_owned();
+    /// let x: Value = s.into();
+    /// ```
+    fn from(f: String) -> Self {
+        Value::String(f)
+    }
+}
+
+impl From<&str> for Value {
+    /// Convert string slice to `Value::String`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let s: &str = "lorem";
+    /// let x: Value = s.into();
+    /// ```
+    fn from(f: &str) -> Self {
+        Value::String(f.to_owned())
+    }
+}
+
+impl<'a> From<Cow<'a, str>> for Value {
+    /// Convert copy-on-write string to `Value::String`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    /// use std::borrow::Cow;
+    ///
+    /// let s: Cow<str> = Cow::Borrowed("lorem");
+    /// let x: Value = s.into();
+    /// ```
+    ///
+    /// ```
+    /// use serde_json::Value;
+    /// use std::borrow::Cow;
+    ///
+    /// let s: Cow<str> = Cow::Owned("lorem".to_owned());
+    /// let x: Value = s.into();
+    /// ```
+    fn from(f: Cow<'a, str>) -> Self {
+        Value::String(f.into_owned())
+    }
+}
+
+impl From<Number> for Value {
+    /// Convert `Number` to `Value::Number`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::{Number, Value};
+    ///
+    /// let n = Number::from(7);
+    /// let x: Value = n.into();
+    /// ```
+    fn from(f: Number) -> Self {
+        Value::Number(f)
+    }
+}
+
+impl From<Map<String, Value>> for Value {
+    /// Convert map (with string keys) to `Value::Object`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::{Map, Value};
+    ///
+    /// let mut m = Map::new();
+    /// m.insert("Lorem".to_owned(), "ipsum".into());
+    /// let x: Value = m.into();
+    /// ```
+    fn from(f: Map<String, Value>) -> Self {
+        Value::Object(f)
+    }
+}
+
+impl<T: Into<Value>> From<Vec<T>> for Value {
+    /// Convert a `Vec` to `Value::Array`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let v = vec!["lorem", "ipsum", "dolor"];
+    /// let x: Value = v.into();
+    /// ```
+    fn from(f: Vec<T>) -> Self {
+        Value::Array(f.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<T: Into<Value>, const N: usize> From<[T; N]> for Value {
+    fn from(array: [T; N]) -> Self {
+        Value::Array(array.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<T: Clone + Into<Value>> From<&[T]> for Value {
+    /// Convert a slice to `Value::Array`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
+    /// let x: Value = v.into();
+    /// ```
+    fn from(f: &[T]) -> Self {
+        Value::Array(f.iter().cloned().map(Into::into).collect())
+    }
+}
+
+impl<T: Into<Value>> FromIterator<T> for Value {
+    /// Create a `Value::Array` by collecting an iterator of array elements.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let v = std::iter::repeat(42).take(5);
+    /// let x: Value = v.collect();
+    /// ```
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
+    /// let x: Value = v.into_iter().collect();
+    /// ```
+    ///
+    /// ```
+    /// use std::iter::FromIterator;
+    /// use serde_json::Value;
+    ///
+    /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
+    /// ```
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        Value::Array(iter.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<K: Into<String>, V: Into<Value>> FromIterator<(K, V)> for Value {
+    /// Create a `Value::Object` by collecting an iterator of key-value pairs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];
+    /// let x: Value = v.into_iter().collect();
+    /// ```
+    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
+        Value::Object(
+            iter.into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
+        )
+    }
+}
+
+impl From<()> for Value {
+    /// Convert `()` to `Value::Null`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use serde_json::Value;
+    ///
+    /// let u = ();
+    /// let x: Value = u.into();
+    /// ```
+    fn from((): ()) -> Self {
+        Value::Null
+    }
+}
+
+impl<T> From<Option<T>> for Value
+where
+    T: Into<Value>,
+{
+    fn from(opt: Option<T>) -> Self {
+        match opt {
+            None => Value::Null,
+            Some(value) => Into::into(value),
+        }
+    }
+}

vendor/serde_json/src/value/index.rs

@@ -0,0 +1,258 @@
+use super::Value;
+use crate::map::Map;
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use core::fmt::{self, Display};
+use core::ops;
+
+/// A type that can be used to index into a `serde_json::Value`.
+///
+/// The [`get`] and [`get_mut`] methods of `Value` accept any type that
+/// implements `Index`, as does the [square-bracket indexing operator]. This
+/// trait is implemented for strings which are used as the index into a JSON
+/// map, and for `usize` which is used as the index into a JSON array.
+///
+/// [`get`]: Value::get
+/// [`get_mut`]: Value::get_mut
+/// [square-bracket indexing operator]: Value#impl-Index%3CI%3E-for-Value
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `serde_json`.
+///
+/// # Examples
+///
+/// ```
+/// # use serde_json::json;
+/// #
+/// let data = json!({ "inner": [1, 2, 3] });
+///
+/// // Data is a JSON map so it can be indexed with a string.
+/// let inner = &data["inner"];
+///
+/// // Inner is a JSON array so it can be indexed with an integer.
+/// let first = &inner[0];
+///
+/// assert_eq!(first, 1);
+/// ```
+pub trait Index: private::Sealed {
+    /// Return None if the key is not already in the array 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 array or object.
+    #[doc(hidden)]
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
+
+    /// Panic if array 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::Array(vec) => vec.get(*self),
+            _ => None,
+        }
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        match v {
+            Value::Array(vec) => vec.get_mut(*self),
+            _ => None,
+        }
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        match v {
+            Value::Array(vec) => {
+                let len = vec.len();
+                vec.get_mut(*self).unwrap_or_else(|| {
+                    panic!(
+                        "cannot access index {} of JSON array of length {}",
+                        self, len
+                    )
+                })
+            }
+            _ => panic!("cannot access index {} of JSON {}", self, Type(v)),
+        }
+    }
+}
+
+impl Index for str {
+    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+        match v {
+            Value::Object(map) => map.get(self),
+            _ => None,
+        }
+    }
+    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+        match v {
+            Value::Object(map) => map.get_mut(self),
+            _ => None,
+        }
+    }
+    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+        if let Value::Null = v {
+            *v = Value::Object(Map::new());
+        }
+        match v {
+            Value::Object(map) => map.entry(self.to_owned()).or_insert(Value::Null),
+            _ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
+        }
+    }
+}
+
+impl Index for String {
+    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)
+    }
+}
+
+impl<T> Index for &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 alloc::string::String {}
+    impl<T> Sealed for &T where T: ?Sized + Sealed {}
+}
+
+/// Used in panic messages.
+struct Type<'a>(&'a Value);
+
+impl<'a> 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::Array(_) => formatter.write_str("array"),
+            Value::Object(_) => formatter.write_str("object"),
+        }
+    }
+}
+
+// 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 JSON 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_array() and working with the Vec directly, or matching on
+// Value::Array 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_array, 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_json::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 an array
+    /// 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 array.
+    ///
+    /// For retrieving deeply nested values, you should have a look at the
+    /// `Value::pointer` method.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let data = json!({
+    ///     "x": {
+    ///         "y": ["z", "zz"]
+    ///     }
+    /// });
+    ///
+    /// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
+    /// assert_eq!(data["x"]["y"][0], json!("z"));
+    ///
+    /// assert_eq!(data["a"], json!(null)); // returns null for undefined values
+    /// assert_eq!(data["a"]["b"], json!(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_json::Value` using the syntax `value[0] = ...` or
+    /// `value["k"] = ...`.
+    ///
+    /// If the index is a number, the value must be an array of length bigger
+    /// than the index. Indexing into a value that is not an array or an array
+    /// 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
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let mut data = json!({ "x": 0 });
+    ///
+    /// // replace an existing key
+    /// data["x"] = json!(1);
+    ///
+    /// // insert a new key
+    /// data["y"] = json!([false, false, false]);
+    ///
+    /// // replace an array value
+    /// data["y"][0] = json!(true);
+    ///
+    /// // inserted a deeply nested key
+    /// data["a"]["b"]["c"]["d"] = json!(true);
+    ///
+    /// println!("{}", data);
+    /// ```
+    fn index_mut(&mut self, index: I) -> &mut Value {
+        index.index_or_insert(self)
+    }
+}

vendor/serde_json/src/value/partial_eq.rs

@@ -0,0 +1,103 @@
+use super::Value;
+use alloc::string::String;
+
+fn eq_i64(value: &Value, other: i64) -> bool {
+    value.as_i64() == Some(other)
+}
+
+fn eq_u64(value: &Value, other: u64) -> bool {
+    value.as_u64() == Some(other)
+}
+
+fn eq_f32(value: &Value, other: f32) -> bool {
+    match value {
+        Value::Number(n) => n.as_f32() == Some(other),
+        _ => false,
+    }
+}
+
+fn eq_f64(value: &Value, other: f64) -> bool {
+    value.as_f64() == Some(other)
+}
+
+fn eq_bool(value: &Value, other: bool) -> bool {
+    value.as_bool() == Some(other)
+}
+
+fn eq_str(value: &Value, other: &str) -> bool {
+    value.as_str() == Some(other)
+}
+
+impl PartialEq<str> for Value {
+    fn eq(&self, other: &str) -> bool {
+        eq_str(self, other)
+    }
+}
+
+impl PartialEq<&str> for Value {
+    fn eq(&self, other: &&str) -> bool {
+        eq_str(self, *other)
+    }
+}
+
+impl PartialEq<Value> for str {
+    fn eq(&self, other: &Value) -> bool {
+        eq_str(other, self)
+    }
+}
+
+impl PartialEq<Value> for &str {
+    fn eq(&self, other: &Value) -> bool {
+        eq_str(other, *self)
+    }
+}
+
+impl PartialEq<String> for Value {
+    fn eq(&self, other: &String) -> bool {
+        eq_str(self, other.as_str())
+    }
+}
+
+impl PartialEq<Value> for String {
+    fn eq(&self, other: &Value) -> bool {
+        eq_str(other, self.as_str())
+    }
+}
+
+macro_rules! partialeq_numeric {
+    ($($eq:ident [$($ty:ty)*])*) => {
+        $($(
+            impl PartialEq<$ty> for Value {
+                fn eq(&self, other: &$ty) -> bool {
+                    $eq(self, *other as _)
+                }
+            }
+
+            impl PartialEq<Value> for $ty {
+                fn eq(&self, other: &Value) -> bool {
+                    $eq(other, *self as _)
+                }
+            }
+
+            impl<'a> PartialEq<$ty> for &'a Value {
+                fn eq(&self, other: &$ty) -> bool {
+                    $eq(*self, *other as _)
+                }
+            }
+
+            impl<'a> PartialEq<$ty> for &'a mut Value {
+                fn eq(&self, other: &$ty) -> bool {
+                    $eq(*self, *other as _)
+                }
+            }
+        )*)*
+    }
+}
+
+partialeq_numeric! {
+    eq_i64[i8 i16 i32 i64 isize]
+    eq_u64[u8 u16 u32 u64 usize]
+    eq_f32[f32]
+    eq_f64[f64]
+    eq_bool[bool]
+}