nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1806766 - Update serde_json to 1.0.91. r=emilio,supply-chain-reviewers

Browse source 
Differential Revision: https://phabricator.services.mozilla.com/D165539
This commit is contained in:
Mike Hommey 2022-12-27 20:45:13 +00:00
parent dd219c949e
commit 420eb54c16
24 changed files with 334 additions and 407 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

4
Cargo.lock generated
View file

@ -4788,9 +4788,9 @@ dependencies = [
[[package]]
name = "serde_json"
version = "1.0.85"
version = "1.0.91"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44"
checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
dependencies = [
"indexmap",
"itoa",

5
supply-chain/audits.toml
View file

@ -1665,6 +1665,11 @@ who = "Mike Hommey <mh+mozilla@glandium.org>"
criteria = "safe-to-deploy"
delta = "1.0.83 -> 1.0.85"
[[audits.serde_json]]
who = "Mike Hommey <mh+mozilla@glandium.org>"
criteria = "safe-to-deploy"
delta = "1.0.85 -> 1.0.91"
[[audits.serde_repr]]
who = "Mike Hommey <mh+mozilla@glandium.org>"
criteria = "safe-to-run"

2
third_party/rust/serde_json/.cargo-checksum.json vendored
View file

File diff suppressed because one or more lines are too long

5
third_party/rust/serde_json/Cargo.toml vendored
View file

@ -13,7 +13,7 @@
edition = "2018"
rust-version = "1.36"
name = "serde_json"
version = "1.0.85"
version = "1.0.91"
authors = [
"Erick Tryzelaar <erick.tryzelaar@gmail.com>",
"David Tolnay <dtolnay@gmail.com>",
@ -48,6 +48,9 @@ rustdoc-args = [
[package.metadata.playground]
features = ["raw_value"]
[lib]
doc-scrape-examples = false
[dependencies.indexmap]
version = "1.5.2"
features = ["std"]

10
third_party/rust/serde_json/README.md vendored
View file

@ -1,7 +1,7 @@
# Serde JSON &emsp; [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.36+]][rustc]
# Serde JSON &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![Rustc Version 1.36+]][rustc]
[Build Status]: https://img.shields.io/github/workflow/status/serde-rs/json/CI/master
[travis]: https://github.com/serde-rs/json/actions?query=branch%3Amaster
[Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/json/ci.yml?branch=master
[actions]: https://github.com/serde-rs/json/actions?query=branch%3Amaster
[Latest Version]: https://img.shields.io/crates/v/serde_json.svg
[crates.io]: https://crates.io/crates/serde\_json
[Rustc Version 1.36+]: https://img.shields.io/badge/rustc-1.36+-lightgray.svg
@ -350,8 +350,8 @@ closed without a response after some time.
## No-std support
As long as there is a memory allocator, it is possible to use serde_json without
the rest of the Rust standard library. This is supported on Rust 1.36+. Disable
the default "std" feature and enable the "alloc" feature:
the rest of the Rust standard library. Disable the default "std" feature and
enable the "alloc" feature:
```toml
[dependencies]

2
third_party/rust/serde_json/build.rs vendored
View file

@ -3,6 +3,8 @@ use std::process::Command;
use std::str::{self, FromStr};
fn main() {
println!("cargo:rerun-if-changed=build.rs");
// Decide ideal limb width for arithmetic in the float parser. Refer to
// src/lexical/math.rs for where this has an effect.
let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();

160
third_party/rust/serde_json/src/de.rs vendored
View file

@ -14,7 +14,7 @@ use core::marker::PhantomData;
use core::result;
use core::str::FromStr;
use serde::de::{self, Expected, Unexpected};
use serde::{forward_to_deserialize_any, serde_if_integer128};
use serde::forward_to_deserialize_any;
#[cfg(feature = "arbitrary_precision")]
use crate::number::NumberDeserializer;
@ -335,31 +335,25 @@ impl<'de, R: Read<'de>> Deserializer<R> {
}
}
serde_if_integer128! {
fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
match tri!(self.next_char_or_null()) {
b'0' => {
buf.push('0');
// There can be only one leading '0'.
match tri!(self.peek_or_null()) {
b'0'..=b'9' => {
Err(self.peek_error(ErrorCode::InvalidNumber))
}
_ => Ok(()),
}
}
c @ b'1'..=b'9' => {
buf.push(c as char);
while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
self.eat_char();
buf.push(c as char);
}
Ok(())
}
_ => {
Err(self.error(ErrorCode::InvalidNumber))
fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
match tri!(self.next_char_or_null()) {
b'0' => {
buf.push('0');
// There can be only one leading '0'.
match tri!(self.peek_or_null()) {
b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
_ => Ok(()),
}
}
c @ b'1'..=b'9' => {
buf.push(c as char);
while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
self.eat_char();
buf.push(c as char);
}
Ok(())
}
_ => Err(self.error(ErrorCode::InvalidNumber)),
}
}
@ -457,30 +451,33 @@ impl<'de, R: Read<'de>> Deserializer<R> {
&mut self,
positive: bool,
mut significand: u64,
mut exponent: i32,
exponent_before_decimal_point: i32,
) -> Result<f64> {
self.eat_char();
let mut exponent_after_decimal_point = 0;
while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
let digit = (c - b'0') as u64;
if overflow!(significand * 10 + digit, u64::max_value()) {
let exponent = exponent_before_decimal_point + exponent_after_decimal_point;
return self.parse_decimal_overflow(positive, significand, exponent);
}
self.eat_char();
significand = significand * 10 + digit;
exponent -= 1;
exponent_after_decimal_point -= 1;
}
// Error if there is not at least one digit after the decimal point.
if exponent == 0 {
if exponent_after_decimal_point == 0 {
match tri!(self.peek()) {
Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
}
}
let exponent = exponent_before_decimal_point + exponent_after_decimal_point;
match tri!(self.peek_or_null()) {
b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
_ => self.f64_from_parts(positive, significand, exponent),
@ -1437,67 +1434,65 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
val
}
serde_if_integer128! {
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
let mut buf = String::new();
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
let mut buf = String::new();
match tri!(self.parse_whitespace()) {
Some(b'-') => {
self.eat_char();
buf.push('-');
}
Some(_) => {}
None => {
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
}
};
match tri!(self.parse_whitespace()) {
Some(b'-') => {
self.eat_char();
buf.push('-');
}
Some(_) => {}
None => {
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
}
};
tri!(self.scan_integer128(&mut buf));
tri!(self.scan_integer128(&mut buf));
let value = match buf.parse() {
Ok(int) => visitor.visit_i128(int),
Err(_) => {
return Err(self.error(ErrorCode::NumberOutOfRange));
}
};
let value = match buf.parse() {
Ok(int) => visitor.visit_i128(int),
Err(_) => {
return Err(self.error(ErrorCode::NumberOutOfRange));
}
};
match value {
Ok(value) => Ok(value),
Err(err) => Err(self.fix_position(err)),
match value {
Ok(value) => Ok(value),
Err(err) => Err(self.fix_position(err)),
}
}
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
match tri!(self.parse_whitespace()) {
Some(b'-') => {
return Err(self.peek_error(ErrorCode::NumberOutOfRange));
}
Some(_) => {}
None => {
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
}
}
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
match tri!(self.parse_whitespace()) {
Some(b'-') => {
return Err(self.peek_error(ErrorCode::NumberOutOfRange));
}
Some(_) => {}
None => {
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
}
let mut buf = String::new();
tri!(self.scan_integer128(&mut buf));
let value = match buf.parse() {
Ok(int) => visitor.visit_u128(int),
Err(_) => {
return Err(self.error(ErrorCode::NumberOutOfRange));
}
};
let mut buf = String::new();
tri!(self.scan_integer128(&mut buf));
let value = match buf.parse() {
Ok(int) => visitor.visit_u128(int),
Err(_) => {
return Err(self.error(ErrorCode::NumberOutOfRange));
}
};
match value {
Ok(value) => Ok(value),
Err(err) => Err(self.fix_position(err)),
}
match value {
Ok(value) => Ok(value),
Err(err) => Err(self.fix_position(err)),
}
}
@ -2164,15 +2159,12 @@ where
deserialize_integer_key!(deserialize_i16 => visit_i16);
deserialize_integer_key!(deserialize_i32 => visit_i32);
deserialize_integer_key!(deserialize_i64 => visit_i64);
deserialize_integer_key!(deserialize_i128 => visit_i128);
deserialize_integer_key!(deserialize_u8 => visit_u8);
deserialize_integer_key!(deserialize_u16 => visit_u16);
deserialize_integer_key!(deserialize_u32 => visit_u32);
deserialize_integer_key!(deserialize_u64 => visit_u64);
serde_if_integer128! {
deserialize_integer_key!(deserialize_i128 => visit_i128);
deserialize_integer_key!(deserialize_u128 => visit_u128);
}
deserialize_integer_key!(deserialize_u128 => visit_u128);
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>

6
third_party/rust/serde_json/src/lib.rs vendored
View file

@ -279,8 +279,8 @@
//! # No-std support
//!
//! As long as there is a memory allocator, it is possible to use serde_json
//! without the rest of the Rust standard library. This is supported on Rust
//! 1.36+. Disable the default "std" feature and enable the "alloc" feature:
//! without the rest of the Rust standard library. Disable the default "std"
//! feature and enable the "alloc" feature:
//!
//! ```toml
//! [dependencies]
@ -300,7 +300,7 @@
//! [macro]: https://docs.serde.rs/serde_json/macro.json.html
//! [`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-core
#![doc(html_root_url = "https://docs.rs/serde_json/1.0.85")]
#![doc(html_root_url = "https://docs.rs/serde_json/1.0.91")]
// Ignored clippy lints
#![allow(
clippy::collapsible_else_if,

10
third_party/rust/serde_json/src/map.rs vendored
View file

@ -197,9 +197,8 @@ impl Map<String, Value> {
#[inline]
pub fn append(&mut self, other: &mut Self) {
#[cfg(feature = "preserve_order")]
for (k, v) in mem::replace(&mut other.map, MapImpl::default()) {
self.map.insert(k, v);
}
self.map
.extend(mem::replace(&mut other.map, MapImpl::default()));
#[cfg(not(feature = "preserve_order"))]
self.map.append(&mut other.map);
}
@ -304,6 +303,11 @@ impl Clone for Map<String, Value> {
map: self.map.clone(),
}
}
#[inline]
fn clone_from(&mut self, source: &Self) {
self.map.clone_from(&source.map);
}
}
impl PartialEq for Map<String, Value> {

46
third_party/rust/serde_json/src/number.rs vendored
View file

@ -1,18 +1,18 @@
use crate::de::ParserNumber;
use crate::error::Error;
#[cfg(feature = "arbitrary_precision")]
use crate::error::ErrorCode;
#[cfg(feature = "arbitrary_precision")]
use alloc::borrow::ToOwned;
#[cfg(feature = "arbitrary_precision")]
use alloc::string::{String, ToString};
use core::fmt::{self, Debug, Display};
#[cfg(not(feature = "arbitrary_precision"))]
use core::hash::{Hash, Hasher};
use serde::de::{self, Unexpected, Visitor};
use serde::{
forward_to_deserialize_any, serde_if_integer128, Deserialize, Deserializer, Serialize,
Serializer,
};
#[cfg(feature = "arbitrary_precision")]
use crate::error::ErrorCode;
#[cfg(feature = "arbitrary_precision")]
use serde::de::{IntoDeserializer, MapAccess};
use serde::{forward_to_deserialize_any, Deserialize, Deserializer, Serialize, Serializer};
#[cfg(feature = "arbitrary_precision")]
pub(crate) const TOKEN: &str = "$serde_json::private::Number";
@ -537,18 +537,15 @@ impl<'de> Deserializer<'de> for Number {
deserialize_number!(deserialize_i16 => visit_i16);
deserialize_number!(deserialize_i32 => visit_i32);
deserialize_number!(deserialize_i64 => visit_i64);
deserialize_number!(deserialize_i128 => visit_i128);
deserialize_number!(deserialize_u8 => visit_u8);
deserialize_number!(deserialize_u16 => visit_u16);
deserialize_number!(deserialize_u32 => visit_u32);
deserialize_number!(deserialize_u64 => visit_u64);
deserialize_number!(deserialize_u128 => visit_u128);
deserialize_number!(deserialize_f32 => visit_f32);
deserialize_number!(deserialize_f64 => visit_f64);
serde_if_integer128! {
deserialize_number!(deserialize_i128 => visit_i128);
deserialize_number!(deserialize_u128 => visit_u128);
}
forward_to_deserialize_any! {
bool char str string bytes byte_buf option unit unit_struct
newtype_struct seq tuple tuple_struct map struct enum identifier
@ -565,18 +562,15 @@ impl<'de, 'a> Deserializer<'de> for &'a Number {
deserialize_number!(deserialize_i16 => visit_i16);
deserialize_number!(deserialize_i32 => visit_i32);
deserialize_number!(deserialize_i64 => visit_i64);
deserialize_number!(deserialize_i128 => visit_i128);
deserialize_number!(deserialize_u8 => visit_u8);
deserialize_number!(deserialize_u16 => visit_u16);
deserialize_number!(deserialize_u32 => visit_u32);
deserialize_number!(deserialize_u64 => visit_u64);
deserialize_number!(deserialize_u128 => visit_u128);
deserialize_number!(deserialize_f32 => visit_f32);
deserialize_number!(deserialize_f64 => visit_f64);
serde_if_integer128! {
deserialize_number!(deserialize_i128 => visit_i128);
deserialize_number!(deserialize_u128 => visit_u128);
}
forward_to_deserialize_any! {
bool char str string bytes byte_buf option unit unit_struct
newtype_struct seq tuple tuple_struct map struct enum identifier
@ -728,21 +722,9 @@ impl_from_unsigned!(u8, u16, u32, u64, usize);
impl_from_signed!(i8, i16, i32, i64, isize);
#[cfg(feature = "arbitrary_precision")]
serde_if_integer128! {
impl From<i128> for Number {
fn from(i: i128) -> Self {
let n = itoa::Buffer::new().format(i).to_owned();
Number { n }
}
}
impl From<u128> for Number {
fn from(u: u128) -> Self {
let n = itoa::Buffer::new().format(u).to_owned();
Number { n }
}
}
}
impl_from_unsigned!(u128);
#[cfg(feature = "arbitrary_precision")]
impl_from_signed!(i128);
impl Number {
#[cfg(not(feature = "arbitrary_precision"))]

382
third_party/rust/serde_json/src/ser.rs vendored
View file

@ -7,7 +7,6 @@ use alloc::vec::Vec;
use core::fmt::{self, Display};
use core::num::FpCategory;
use serde::ser::{self, Impossible, Serialize};
use serde::serde_if_integer128;
/// A structure for serializing Rust values into JSON.
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
@ -75,137 +74,105 @@ where
#[inline]
fn serialize_bool(self, value: bool) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_bool(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_i8(self, value: i8) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_i8(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_i16(self, value: i16) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_i16(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_i32(self, value: i32) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_i32(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_i64(self, value: i64) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_i64(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
serde_if_integer128! {
fn serialize_i128(self, value: i128) -> Result<()> {
self.formatter
.write_number_str(&mut self.writer, &value.to_string())
.map_err(Error::io)
}
fn serialize_i128(self, value: i128) -> Result<()> {
self.formatter
.write_i128(&mut self.writer, value)
.map_err(Error::io)
}
#[inline]
fn serialize_u8(self, value: u8) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_u8(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_u16(self, value: u16) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_u16(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_u32(self, value: u32) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_u32(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
fn serialize_u64(self, value: u64) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_u64(&mut self.writer, value)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
serde_if_integer128! {
fn serialize_u128(self, value: u128) -> Result<()> {
self.formatter
.write_number_str(&mut self.writer, &value.to_string())
.map_err(Error::io)
}
fn serialize_u128(self, value: u128) -> Result<()> {
self.formatter
.write_u128(&mut self.writer, value)
.map_err(Error::io)
}
#[inline]
fn serialize_f32(self, value: f32) -> Result<()> {
match value.classify() {
FpCategory::Nan | FpCategory::Infinite => {
tri!(self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io));
}
_ => {
tri!(self
.formatter
.write_f32(&mut self.writer, value)
.map_err(Error::io));
}
FpCategory::Nan | FpCategory::Infinite => self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io),
_ => self
.formatter
.write_f32(&mut self.writer, value)
.map_err(Error::io),
}
Ok(())
}
#[inline]
fn serialize_f64(self, value: f64) -> Result<()> {
match value.classify() {
FpCategory::Nan | FpCategory::Infinite => {
tri!(self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io));
}
_ => {
tri!(self
.formatter
.write_f64(&mut self.writer, value)
.map_err(Error::io));
}
FpCategory::Nan | FpCategory::Infinite => self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io),
_ => self
.formatter
.write_f64(&mut self.writer, value)
.map_err(Error::io),
}
Ok(())
}
#[inline]
@ -217,8 +184,7 @@ where
#[inline]
fn serialize_str(self, value: &str) -> Result<()> {
tri!(format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io));
Ok(())
format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io)
}
#[inline]
@ -233,11 +199,9 @@ where
#[inline]
fn serialize_unit(self) -> Result<()> {
tri!(self
.formatter
self.formatter
.write_null(&mut self.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
@ -297,11 +261,9 @@ where
.formatter
.end_object_value(&mut self.writer)
.map_err(Error::io));
tri!(self
.formatter
self.formatter
.end_object(&mut self.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[inline]
@ -490,11 +452,9 @@ where
}
}
}
tri!(self
.formatter
self.formatter
.end_string(&mut self.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
}
@ -541,11 +501,9 @@ where
.map_err(Error::io));
*state = State::Rest;
tri!(value.serialize(&mut **ser));
tri!(ser
.formatter
ser.formatter
.end_array_value(&mut ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
@ -557,13 +515,10 @@ where
#[inline]
fn end(self) -> Result<()> {
match self {
Compound::Map { ser, state } => {
match state {
State::Empty => {}
_ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
}
Ok(())
}
Compound::Map { ser, state } => match state {
State::Empty => Ok(()),
_ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io),
},
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
#[cfg(feature = "raw_value")]
@ -644,8 +599,7 @@ where
.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io));
tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
Ok(())
ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
}
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
@ -678,11 +632,9 @@ where
tri!(key.serialize(MapKeySerializer { ser: *ser }));
tri!(ser
.formatter
ser.formatter
.end_object_key(&mut ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
@ -703,11 +655,9 @@ where
.begin_object_value(&mut ser.writer)
.map_err(Error::io));
tri!(value.serialize(&mut **ser));
tri!(ser
.formatter
ser.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
@ -719,13 +669,10 @@ where
#[inline]
fn end(self) -> Result<()> {
match self {
Compound::Map { ser, state } => {
match state {
State::Empty => {}
_ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
}
Ok(())
}
Compound::Map { ser, state } => match state {
State::Empty => Ok(()),
_ => ser.formatter.end_object(&mut ser.writer).map_err(Error::io),
},
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
#[cfg(feature = "raw_value")]
@ -752,8 +699,7 @@ where
#[cfg(feature = "arbitrary_precision")]
Compound::Number { ser, .. } => {
if key == crate::number::TOKEN {
tri!(value.serialize(NumberStrEmitter(ser)));
Ok(())
value.serialize(NumberStrEmitter(ser))
} else {
Err(invalid_number())
}
@ -761,8 +707,7 @@ where
#[cfg(feature = "raw_value")]
Compound::RawValue { ser, .. } => {
if key == crate::raw::TOKEN {
tri!(value.serialize(RawValueStrEmitter(ser)));
Ok(())
value.serialize(RawValueStrEmitter(ser))
} else {
Err(invalid_raw_value())
}
@ -816,8 +761,7 @@ where
.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io));
tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
Ok(())
ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
}
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
@ -899,12 +843,10 @@ where
.formatter
.write_i8(&mut self.ser.writer, value)
.map_err(Error::io));
tri!(self
.ser
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
fn serialize_i16(self, value: i16) -> Result<()> {
@ -918,12 +860,10 @@ where
.formatter
.write_i16(&mut self.ser.writer, value)
.map_err(Error::io));
tri!(self
.ser
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
fn serialize_i32(self, value: i32) -> Result<()> {
@ -937,12 +877,10 @@ where
.formatter
.write_i32(&mut self.ser.writer, value)
.map_err(Error::io));
tri!(self
.ser
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
fn serialize_i64(self, value: i64) -> Result<()> {
@ -956,33 +894,27 @@ where
.formatter
.write_i64(&mut self.ser.writer, value)
.map_err(Error::io));
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
}
fn serialize_i128(self, value: i128) -> Result<()> {
tri!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
serde_if_integer128! {
fn serialize_i128(self, value: i128) -> Result<()> {
tri!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
tri!(self
.ser
.formatter
.write_number_str(&mut self.ser.writer, &value.to_string())
.map_err(Error::io));
tri!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
tri!(self
.ser
.formatter
.write_i128(&mut self.ser.writer, value)
.map_err(Error::io));
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
}
fn serialize_u8(self, value: u8) -> Result<()> {
@ -996,12 +928,10 @@ where
.formatter
.write_u8(&mut self.ser.writer, value)
.map_err(Error::io));
tri!(self
.ser
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
fn serialize_u16(self, value: u16) -> Result<()> {
@ -1015,12 +945,10 @@ where
.formatter
.write_u16(&mut self.ser.writer, value)
.map_err(Error::io));
tri!(self
.ser
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
fn serialize_u32(self, value: u32) -> Result<()> {
@ -1034,12 +962,10 @@ where
.formatter
.write_u32(&mut self.ser.writer, value)
.map_err(Error::io));
tri!(self
.ser
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
.map_err(Error::io)
}
fn serialize_u64(self, value: u64) -> Result<()> {
@ -1053,33 +979,27 @@ where
.formatter
.write_u64(&mut self.ser.writer, value)
.map_err(Error::io));
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
}
fn serialize_u128(self, value: u128) -> Result<()> {
tri!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
serde_if_integer128! {
fn serialize_u128(self, value: u128) -> Result<()> {
tri!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
tri!(self
.ser
.formatter
.write_number_str(&mut self.ser.writer, &value.to_string())
.map_err(Error::io));
tri!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
tri!(self
.ser
.formatter
.write_u128(&mut self.ser.writer, value)
.map_err(Error::io));
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
}
fn serialize_f32(self, _value: f32) -> Result<()> {
@ -1218,10 +1138,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W,
Err(invalid_number())
}
serde_if_integer128! {
fn serialize_i128(self, _v: i128) -> Result<()> {
Err(invalid_number())
}
fn serialize_i128(self, _v: i128) -> Result<()> {
Err(invalid_number())
}
fn serialize_u8(self, _v: u8) -> Result<()> {
@ -1240,10 +1158,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W,
Err(invalid_number())
}
serde_if_integer128! {
fn serialize_u128(self, _v: u128) -> Result<()> {
Err(invalid_number())
}
fn serialize_u128(self, _v: u128) -> Result<()> {
Err(invalid_number())
}
fn serialize_f32(self, _v: f32) -> Result<()> {
@ -1399,10 +1315,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a,
Err(ser::Error::custom("expected RawValue"))
}
serde_if_integer128! {
fn serialize_i128(self, _v: i128) -> Result<()> {
Err(ser::Error::custom("expected RawValue"))
}
fn serialize_i128(self, _v: i128) -> Result<()> {
Err(ser::Error::custom("expected RawValue"))
}
fn serialize_u8(self, _v: u8) -> Result<()> {
@ -1421,10 +1335,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a,
Err(ser::Error::custom("expected RawValue"))
}
serde_if_integer128! {
fn serialize_u128(self, _v: u128) -> Result<()> {
Err(ser::Error::custom("expected RawValue"))
}
fn serialize_u128(self, _v: u128) -> Result<()> {
Err(ser::Error::custom("expected RawValue"))
}
fn serialize_f32(self, _v: f32) -> Result<()> {
@ -1661,6 +1573,17 @@ pub trait Formatter {
writer.write_all(s.as_bytes())
}
/// Writes an integer value like `-123` to the specified writer.
#[inline]
fn write_i128<W>(&mut self, writer: &mut W, value: i128) -> io::Result<()>
where
W: ?Sized + io::Write,
{
let mut buffer = itoa::Buffer::new();
let s = buffer.format(value);
writer.write_all(s.as_bytes())
}
/// Writes an integer value like `123` to the specified writer.
#[inline]
fn write_u8<W>(&mut self, writer: &mut W, value: u8) -> io::Result<()>
@ -1705,6 +1628,17 @@ pub trait Formatter {
writer.write_all(s.as_bytes())
}
/// Writes an integer value like `123` to the specified writer.
#[inline]
fn write_u128<W>(&mut self, writer: &mut W, value: u128) -> io::Result<()>
where
W: ?Sized + io::Write,
{
let mut buffer = itoa::Buffer::new();
let s = buffer.format(value);
writer.write_all(s.as_bytes())
}
/// Writes a floating point value like `-31.26e+12` to the specified writer.
#[inline]
fn write_f32<W>(&mut self, writer: &mut W, value: f32) -> io::Result<()>
@ -1985,13 +1919,8 @@ impl<'a> Formatter for PrettyFormatter<'a> {
where
W: ?Sized + io::Write,
{
if first {
tri!(writer.write_all(b"\n"));
} else {
tri!(writer.write_all(b",\n"));
}
tri!(indent(writer, self.current_indent, self.indent));
Ok(())
tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
indent(writer, self.current_indent, self.indent)
}
#[inline]
@ -2033,11 +1962,7 @@ impl<'a> Formatter for PrettyFormatter<'a> {
where
W: ?Sized + io::Write,
{
if first {
tri!(writer.write_all(b"\n"));
} else {
tri!(writer.write_all(b",\n"));
}
tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
indent(writer, self.current_indent, self.indent)
}
@ -2066,8 +1991,7 @@ where
{
tri!(formatter.begin_string(writer));
tri!(format_escaped_str_contents(writer, formatter, value));
tri!(formatter.end_string(writer));
Ok(())
formatter.end_string(writer)
}
fn format_escaped_str_contents<W, F>(
@ -2099,11 +2023,11 @@ where
start = i + 1;
}
if start != bytes.len() {
tri!(formatter.write_string_fragment(writer, &value[start..]));
if start == bytes.len() {
return Ok(());
}
Ok(())
formatter.write_string_fragment(writer, &value[start..])
}
const BB: u8 = b'b'; // \x08
@ -2152,8 +2076,7 @@ where
T: ?Sized + Serialize,
{
let mut ser = Serializer::new(writer);
tri!(value.serialize(&mut ser));
Ok(())
value.serialize(&mut ser)
}
/// Serialize the given data structure as pretty-printed JSON into the IO
@ -2171,8 +2094,7 @@ where
T: ?Sized + Serialize,
{
let mut ser = Serializer::pretty(writer);
tri!(value.serialize(&mut ser));
Ok(())
value.serialize(&mut ser)
}
/// Serialize the given data structure as a JSON byte vector.

27
third_party/rust/serde_json/src/value/de.rs vendored
View file

@ -14,7 +14,7 @@ use serde::de::{
self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
SeqAccess, Unexpected, VariantAccess, Visitor,
};
use serde::{forward_to_deserialize_any, serde_if_integer128};
use serde::forward_to_deserialize_any;
#[cfg(feature = "arbitrary_precision")]
use crate::number::NumberFromString;
@ -228,18 +228,15 @@ impl<'de> serde::Deserializer<'de> for Value {
deserialize_number!(deserialize_i16);
deserialize_number!(deserialize_i32);
deserialize_number!(deserialize_i64);
deserialize_number!(deserialize_i128);
deserialize_number!(deserialize_u8);
deserialize_number!(deserialize_u16);
deserialize_number!(deserialize_u32);
deserialize_number!(deserialize_u64);
deserialize_number!(deserialize_u128);
deserialize_number!(deserialize_f32);
deserialize_number!(deserialize_f64);
serde_if_integer128! {
deserialize_number!(deserialize_i128);
deserialize_number!(deserialize_u128);
}
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where
@ -724,18 +721,15 @@ impl<'de> serde::Deserializer<'de> for &'de Value {
deserialize_value_ref_number!(deserialize_i16);
deserialize_value_ref_number!(deserialize_i32);
deserialize_value_ref_number!(deserialize_i64);
deserialize_number!(deserialize_i128);
deserialize_value_ref_number!(deserialize_u8);
deserialize_value_ref_number!(deserialize_u16);
deserialize_value_ref_number!(deserialize_u32);
deserialize_value_ref_number!(deserialize_u64);
deserialize_number!(deserialize_u128);
deserialize_value_ref_number!(deserialize_f32);
deserialize_value_ref_number!(deserialize_f64);
serde_if_integer128! {
deserialize_number!(deserialize_i128);
deserialize_number!(deserialize_u128);
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: Visitor<'de>,
@ -1000,7 +994,7 @@ impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
V: Visitor<'de>,
{
match self.value {
Some(&Value::Array(ref v)) => {
Some(Value::Array(v)) => {
if v.is_empty() {
visitor.visit_unit()
} else {
@ -1027,7 +1021,7 @@ impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
V: Visitor<'de>,
{
match self.value {
Some(&Value::Object(ref v)) => visit_object_ref(v, visitor),
Some(Value::Object(v)) => visit_object_ref(v, visitor),
Some(other) => Err(serde::de::Error::invalid_type(
other.unexpected(),
&"struct variant",
@ -1156,15 +1150,12 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
deserialize_integer_key!(deserialize_i16 => visit_i16);
deserialize_integer_key!(deserialize_i32 => visit_i32);
deserialize_integer_key!(deserialize_i64 => visit_i64);
deserialize_integer_key!(deserialize_i128 => visit_i128);
deserialize_integer_key!(deserialize_u8 => visit_u8);
deserialize_integer_key!(deserialize_u16 => visit_u16);
deserialize_integer_key!(deserialize_u32 => visit_u32);
deserialize_integer_key!(deserialize_u64 => visit_u64);
serde_if_integer128! {
deserialize_integer_key!(deserialize_i128 => visit_i128);
deserialize_integer_key!(deserialize_u128 => visit_u128);
}
deserialize_integer_key!(deserialize_u128 => visit_u128);
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>

9
third_party/rust/serde_json/src/value/from.rs vendored
View file

@ -6,9 +6,6 @@ use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::iter::FromIterator;
#[cfg(feature = "arbitrary_precision")]
use serde::serde_if_integer128;
macro_rules! from_integer {
($($ty:ident)*) => {
$(
@ -27,10 +24,8 @@ from_integer! {
}
#[cfg(feature = "arbitrary_precision")]
serde_if_integer128! {
from_integer! {
i128 u128
}
from_integer! {
i128 u128
}
impl From<f32> for Value {

25
third_party/rust/serde_json/src/value/ser.rs vendored
View file

@ -9,9 +9,6 @@ use core::fmt::Display;
use core::result;
use serde::ser::{Impossible, Serialize};
#[cfg(feature = "arbitrary_precision")]
use serde::serde_if_integer128;
impl Serialize for Value {
#[inline]
fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
@ -96,10 +93,8 @@ impl serde::Serializer for Serializer {
}
#[cfg(feature = "arbitrary_precision")]
serde_if_integer128! {
fn serialize_i128(self, value: i128) -> Result<Value> {
Ok(Value::Number(value.into()))
}
fn serialize_i128(self, value: i128) -> Result<Value> {
Ok(Value::Number(value.into()))
}
#[inline]
@ -123,10 +118,8 @@ impl serde::Serializer for Serializer {
}
#[cfg(feature = "arbitrary_precision")]
serde_if_integer128! {
fn serialize_u128(self, value: u128) -> Result<Value> {
Ok(Value::Number(value.into()))
}
fn serialize_u128(self, value: u128) -> Result<Value> {
Ok(Value::Number(value.into()))
}
#[inline]
@ -195,7 +188,7 @@ impl serde::Serializer for Serializer {
T: ?Sized + Serialize,
{
let mut values = Map::new();
values.insert(String::from(variant), tri!(to_value(&value)));
values.insert(String::from(variant), tri!(to_value(value)));
Ok(Value::Object(values))
}
@ -314,7 +307,7 @@ impl serde::ser::SerializeSeq for SerializeVec {
where
T: ?Sized + Serialize,
{
self.vec.push(tri!(to_value(&value)));
self.vec.push(tri!(to_value(value)));
Ok(())
}
@ -363,7 +356,7 @@ impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
where
T: ?Sized + Serialize,
{
self.vec.push(tri!(to_value(&value)));
self.vec.push(tri!(to_value(value)));
Ok(())
}
@ -406,7 +399,7 @@ impl serde::ser::SerializeMap for SerializeMap {
// Panic because this indicates a bug in the program rather than an
// expected failure.
let key = key.expect("serialize_value called before serialize_key");
map.insert(key, tri!(to_value(&value)));
map.insert(key, tri!(to_value(value)));
Ok(())
}
#[cfg(feature = "arbitrary_precision")]
@ -663,7 +656,7 @@ impl serde::ser::SerializeStructVariant for SerializeStructVariant {
where
T: ?Sized + Serialize,
{
self.map.insert(String::from(key), tri!(to_value(&value)));
self.map.insert(String::from(key), tri!(to_value(value)));
Ok(())
}

9
third_party/rust/serde_json/tests/regression/issue953.rs vendored Normal file
View file

@ -0,0 +1,9 @@
use serde_json::Value;
#[test]
fn test() {
let x1 = serde_json::from_str::<Value>("18446744073709551615.");
assert!(x1.is_err());
let x2 = serde_json::from_str::<Value>("18446744073709551616.");
assert!(x2.is_err());
}

9
third_party/rust/serde_json/tests/test.rs vendored
View file

@ -6,7 +6,6 @@
clippy::excessive_precision,
clippy::float_cmp,
clippy::items_after_statements,
clippy::let_underscore_drop,
clippy::shadow_unrelated,
clippy::too_many_lines,
clippy::unreadable_literal,
@ -95,7 +94,7 @@ where
let s = to_string(value).unwrap();
assert_eq!(s, out);
let v = to_value(&value).unwrap();
let v = to_value(value).unwrap();
let s = to_string(&v).unwrap();
assert_eq!(s, out);
}
@ -111,7 +110,7 @@ where
let s = to_string_pretty(value).unwrap();
assert_eq!(s, out);
let v = to_value(&value).unwrap();
let v = to_value(value).unwrap();
let s = to_string_pretty(&v).unwrap();
assert_eq!(s, out);
}
@ -1107,7 +1106,7 @@ fn test_parse_string() {
]);
test_parse_ok(vec![
("\"\"", "".to_string()),
("\"\"", String::new()),
("\"foo\"", "foo".to_string()),
(" \"foo\" ", "foo".to_string()),
("\"\\\"\"", "\"".to_string()),
@ -1928,7 +1927,7 @@ fn test_deny_float_key() {
// map with float key
let map = treemap!(Float => "x");
assert!(serde_json::to_value(&map).is_err());
assert!(serde_json::to_value(map).is_err());
}
#[test]

5
third_party/rust/serde_json/tests/ui/missing_colon.stderr vendored
View file

@ -4,4 +4,9 @@ error: unexpected end of macro invocation
4 | json!({ "a" });
| ^^^^^^^^^^^^^^ missing tokens in macro arguments
|
note: while trying to match `@`
--> src/macros.rs
|
| (@array [$($elems:expr,)*]) => {
| ^
= note: this error originates in the macro `json_internal` which comes from the expansion of the macro `json` (in Nightly builds, run with -Z macro-backtrace for more info)

6
third_party/rust/serde_json/tests/ui/missing_comma.stderr vendored
View file

@ -5,3 +5,9 @@ error: no rules expected the token `"2"`
| -^^^ no rules expected this token in macro call
| |
| help: missing comma here
|
note: while trying to match `,`
--> src/macros.rs
|
| ($e:expr , $($tt:tt)*) => {};
| ^

5
third_party/rust/serde_json/tests/ui/missing_value.stderr vendored
View file

@ -4,4 +4,9 @@ error: unexpected end of macro invocation
4 | json!({ "a" : });
| ^^^^^^^^^^^^^^^^ missing tokens in macro arguments
|
note: while trying to match `@`
--> src/macros.rs
|
| (@array [$($elems:expr,)*]) => {
| ^
= note: this error originates in the macro `json_internal` which comes from the expansion of the macro `json` (in Nightly builds, run with -Z macro-backtrace for more info)

6
third_party/rust/serde_json/tests/ui/parse_expr.stderr vendored
View file

@ -3,3 +3,9 @@ error: no rules expected the token `~`
|
4 | json!({ "a" : ~ });
| ^ no rules expected this token in macro call
|
note: while trying to match meta-variable `$e:expr`
--> src/macros.rs
|
| ($e:expr , $($tt:tt)*) => {};
| ^^^^^^^

2
third_party/rust/serde_json/tests/ui/unexpected_after_array_element.stderr vendored
View file

@ -3,3 +3,5 @@ error: no rules expected the token `=>`
|
4 | json!([ true => ]);
| ^^ no rules expected this token in macro call
|
= note: while trying to match end of macro

2
third_party/rust/serde_json/tests/ui/unexpected_after_map_entry.stderr vendored
View file

@ -3,3 +3,5 @@ error: no rules expected the token `=>`
|
4 | json!({ "k": true => });
| ^^ no rules expected this token in macro call
|
= note: while trying to match end of macro

2
third_party/rust/serde_json/tests/ui/unexpected_colon.stderr vendored
View file

@ -3,3 +3,5 @@ error: no rules expected the token `:`
|
4 | json!({ : true });
| ^ no rules expected this token in macro call
|
= note: while trying to match end of macro

2
third_party/rust/serde_json/tests/ui/unexpected_comma.stderr vendored
View file

@ -3,3 +3,5 @@ error: no rules expected the token `,`
|
4 | json!({ "a" , "b": true });
| ^ no rules expected this token in macro call
|
= note: while trying to match end of macro