impl(wkt): custom encoding for i64 and u64

Author: coryan

src/wkt/src/internal.rs

@@ -20,6 +20,13 @@
 mod int32;
 pub use int32::I32;
 
+#[macro_use]
+mod visitor_64;
+mod int64;
+pub use int64::I64;
+mod uint64;
+pub use uint64::U64;
+
 pub struct F32;
 pub struct F64;
 

src/wkt/src/internal/int64.rs

@@ -0,0 +1,97 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Implement custom serializers for `i64`.
+//!
+//! In ProtoJSON 64-bit integers can be serialized as strings, but can be
+//! deserialized from strings or numbers.
+
+use serde::de::Unexpected::Other;
+
+pub struct I64;
+
+impl<'de> serde_with::DeserializeAs<'de, i64> for I64 {
+    fn deserialize_as<D>(deserializer: D) -> Result<i64, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(I64Visitor)
+    }
+}
+
+visitor_64!(I64Visitor, i64, "a 64-bit signed integer");
+
+impl serde_with::SerializeAs<i64> for I64 {
+    fn serialize_as<S>(source: &i64, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_str(source)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use anyhow::Result;
+    use serde_json::{Value, json};
+    use serde_with::{DeserializeAs, SerializeAs};
+    use test_case::test_case;
+
+    #[test_case(0, 0)]
+    #[test_case("0", 0; "zero string")]
+    #[test_case("2.0", 2)]
+    #[test_case(3e5, 300_000)]
+    #[test_case(-4e4, -40_000)]
+    #[test_case("5e4", 50_000)]
+    #[test_case("-6e5", -600_000)]
+    #[test_case(-42, -42)]
+    #[test_case("-7", -7)]
+    #[test_case(84, 84)]
+    #[test_case(168.0, 168)]
+    #[test_case("21", 21)]
+    #[test_case(i64::MAX, i64::MAX; "max")]
+    #[test_case(i64::MAX as f64, i64::MAX; "max as f64")]
+    #[test_case(format!("{}", i64::MAX), i64::MAX; "max as string")]
+    #[test_case(format!("{}.0", i64::MAX), i64::MAX; "max as f64 string")]
+    #[test_case(i64::MIN, i64::MIN; "min")]
+    #[test_case(i64::MIN as f64, i64::MIN; "min as f64")]
+    #[test_case(format!("{}", i64::MIN), i64::MIN; "min as string")]
+    #[test_case(format!("{}.0", i64::MIN), i64::MIN; "min as f64 string")]
+    // Not quite a roundtrip test because we always serialize as numbers.
+    fn deser_and_ser<T: serde::Serialize>(input: T, want: i64) -> Result<()> {
+        let got = I64::deserialize_as(json!(input))?;
+        assert_eq!(got, want);
+
+        let serialized = I64::serialize_as(&got, serde_json::value::Serializer)?;
+        assert_eq!(serialized, json!(got.to_string()));
+        Ok(())
+    }
+
+    #[test_case(json!(i64::MAX as f64 * 2.0))]
+    #[test_case(json!(i64::MIN as f64 * 2.0))]
+    #[test_case(json!(format!("{}", i64::MAX as f64 * 2.0)))]
+    #[test_case(json!(format!("{}", i64::MIN as f64 * 2.0)))]
+    #[test_case(json!(format!("{}", i64::MAX as i128 + 1)); "MAX+1 as string")]
+    #[test_case(json!(format!("{}", i64::MIN as i128 - 1)); "MIN-1 as string")]
+    #[test_case(json!("abc"))]
+    #[test_case(json!(123.4))]
+    #[test_case(json!("234.5"))]
+    #[test_case(json!("-345.6"))]
+    #[test_case(json!({}))]
+    fn deser_error(input: Value) {
+        let got = I64::deserialize_as(input).unwrap_err();
+        assert!(got.is_data(), "{got:?}");
+    }
+}

src/wkt/src/internal/uint64.rs

@@ -0,0 +1,89 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Implement custom serializers for `u64`.
+//!
+//! In ProtoJSON 64-bit integers can be serialized as either strings or numbers.
+
+use serde::de::Unexpected::Other;
+
+pub struct U64;
+
+impl<'de> serde_with::DeserializeAs<'de, u64> for U64 {
+    fn deserialize_as<D>(deserializer: D) -> Result<u64, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(U64Visitor)
+    }
+}
+
+visitor_64!(U64Visitor, u64, "a 64-bit unsigned integer");
+
+impl serde_with::SerializeAs<u64> for U64 {
+    fn serialize_as<S>(source: &u64, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_str(source)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use anyhow::Result;
+    use serde_json::{Value, json};
+    use serde_with::{DeserializeAs, SerializeAs};
+    use test_case::test_case;
+
+    #[test_case(0, 0)]
+    #[test_case("0", 0; "zero string")]
+    #[test_case("2.0", 2)]
+    #[test_case(3e5, 300_000)]
+    #[test_case("5e4", 50_000)]
+    #[test_case(84, 84)]
+    #[test_case(168.0, 168)]
+    #[test_case("21", 21)]
+    #[test_case(u64::MAX, u64::MAX; "max")]
+    #[test_case(u64::MAX as f64, u64::MAX; "max as f64")]
+    #[test_case(format!("{}", u64::MAX), u64::MAX; "max as string")]
+    #[test_case(format!("{}.0", u64::MAX), u64::MAX; "max as f64 string")]
+    #[test_case(u64::MIN, u64::MIN; "min")]
+    #[test_case(u64::MIN as f64, u64::MIN; "min as f64")]
+    #[test_case(format!("{}", u64::MIN), u64::MIN; "min as string")]
+    #[test_case(format!("{}.0", u64::MIN), u64::MIN; "min as f64 string")]
+    // Not quite a roundtrip test because we always serialize as numbers.
+    fn deser_and_ser<T: serde::Serialize>(input: T, want: u64) -> Result<()> {
+        let got = U64::deserialize_as(json!(input))?;
+        assert_eq!(got, want);
+
+        let serialized = U64::serialize_as(&got, serde_json::value::Serializer)?;
+        assert_eq!(serialized, json!(got.to_string()));
+        Ok(())
+    }
+
+    #[test_case(json!(u64::MAX as f64 * 2.0))]
+    #[test_case(json!(format!("{}", u64::MAX as f64 * 2.0)))]
+    #[test_case(json!(format!("{}", u64::MAX as i128 + 1)); "MAX+1 as string")]
+    #[test_case(json!(format!("{}", u64::MIN as i128 - 1)); "MIN-1 as string")]
+    #[test_case(json!("abc"))]
+    #[test_case(json!(123.4))]
+    #[test_case(json!("234.5"))]
+    #[test_case(json!({}))]
+    fn deser_error(input: Value) {
+        let got = U64::deserialize_as(input).unwrap_err();
+        assert!(got.is_data(), "{got:?}");
+    }
+}

src/wkt/src/internal/visitor_64.rs

@@ -0,0 +1,104 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+macro_rules! visitor_64 {
+    ($name: ident, $t: ty, $msg: literal) => {
+        struct $name;
+
+        impl serde::de::Visitor<'_> for $name {
+            type Value = $t;
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                // ProtoJSON says that both strings and numbers are accepted.
+                // The difficulty is dealing with integer strings that are just
+                // outside the range for i64 or u64. Parsing as `f64` rounds
+                // those numbers and may result in incorrectly accepting the
+                // value.
+                //
+                // First try to parse the string as a i128, if it works and it
+                // is in range, return that value.
+                if let Ok(v) = value.parse::<i128>() {
+                    return self.visit_i128(v);
+                }
+                // Next, try to parse it as a `f64` number (all JSON numbers are
+                // `f64`) and then try to parse the result as the target type.
+                let number = value.parse::<f64>().map_err(E::custom)?;
+                self.visit_f64(number)
+            }
+
+            fn visit_i64<E>(self, value: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    _ if value < <$t>::MIN as i64 => Err(self::value_error(value)),
+                    _ => Ok(value as Self::Value),
+                }
+            }
+
+            fn visit_u64<E>(self, value: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    _ if value > <$t>::MAX as u64 => Err(self::value_error(value)),
+                    _ => Ok(value as Self::Value),
+                }
+            }
+
+            fn visit_f64<E>(self, value: f64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    _ if value < <$t>::MIN as f64 => Err(self::value_error(value)),
+                    _ if value > <$t>::MAX as f64 => Err(self::value_error(value)),
+                    _ if value.fract() != 0.0 => Err(self::value_error(value)),
+                    // In Rust floating point to integer conversions are
+                    // "rounded towards zero":
+                    //     https://doc.rust-lang.org/reference/expressions/operator-expr.html#r-expr.as.numeric.float-as-int
+                    // Because we are in range, and the fractional part is zero,
+                    // this conversion is safe.
+                    _ => Ok(value as Self::Value),
+                }
+            }
+
+            fn visit_i128<E>(self, value: i128) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    _ if value < <$t>::MIN as i128 => Err(self::value_error(value)),
+                    _ if value > <$t>::MAX as i128 => Err(self::value_error(value)),
+                    _ => Ok(value as Self::Value),
+                }
+            }
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str($msg)
+            }
+        }
+
+        fn value_error<T, E>(value: T) -> E
+        where
+            T: std::fmt::Display,
+            E: serde::de::Error,
+        {
+            E::invalid_value(Other(&format!("{value}")), &$msg)
+        }
+    };
+}