impl(wkt): support custom u32 encoding (#2342)

Author: coryan

src/wkt/src/internal.rs

@@ -17,8 +17,12 @@
 //! These types are intended for developers of the Google Cloud client libraries
 //! for Rust. They are undocumented and may change at any time.
 
+#[macro_use]
+mod visitor_32;
 mod int32;
 pub use int32::I32;
+mod uint32;
+pub use uint32::U32;
 
 pub struct F32;
 pub struct F64;

src/wkt/src/internal/int32.rs

@@ -29,72 +29,7 @@ impl<'de> serde_with::DeserializeAs<'de, i32> for I32 {
     }
 }
 
-const ERRMSG: &str = "a 32-bit signed integer";
-
-struct I32Visitor;
-
-impl serde::de::Visitor<'_> for I32Visitor {
-    type Value = i32;
-
-    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. Parse the
-        // string as a `f64` number (all JSON numbers are `f64`) and then try to
-        // parse that as an `i32`.
-        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 < i32::MIN as i64 => Err(self::value_error(value)),
-            _ if value > i32::MAX as i64 => Err(self::value_error(value)),
-            _ => Ok(value as i32),
-        }
-    }
-
-    fn visit_u64<E>(self, value: u64) -> std::result::Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        match value {
-            _ if value > i32::MAX as u64 => Err(self::value_error(value)),
-            _ => Ok(value as i32),
-        }
-    }
-
-    fn visit_f64<E>(self, value: f64) -> std::result::Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        match value {
-            _ if value < i32::MIN as f64 => Err(self::value_error(value)),
-            _ if value > i32::MAX as f64 => Err(self::value_error(value)),
-            _ if value.fract().abs() > 0.0 => Err(self::value_error(value)),
-            // The number is "rounded towards zero". Because we are in range,
-            // and the fractional part is 0, this conversion should be safe.
-            // See https://doc.rust-lang.org/reference/expressions/operator-expr.html#r-expr.as.numeric.float-as-int
-            _ => Ok(value as i32),
-        }
-    }
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("a 32-bit integer in ProtoJSON format")
-    }
-}
-
-fn value_error<T, E>(value: T) -> E
-where
-    T: std::fmt::Display,
-    E: serde::de::Error,
-{
-    E::invalid_value(Other(&format!("{value}")), &ERRMSG)
-}
+visitor_32!(I32Visitor, i32, "a 32-bit signed integer");
 
 impl serde_with::SerializeAs<i32> for I32 {
     fn serialize_as<S>(source: &i32, serializer: S) -> Result<S::Ok, S::Error>

src/wkt/src/internal/uint32.rs

@@ -0,0 +1,91 @@
+// 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 `u32`.
+//!
+//! In ProtoJSON 32-bit integers can be serialized as either strings or numbers.
+
+use serde::de::Unexpected::Other;
+
+pub struct U32;
+
+impl<'de> serde_with::DeserializeAs<'de, u32> for U32 {
+    fn deserialize_as<D>(deserializer: D) -> Result<u32, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(U32Visitor)
+    }
+}
+
+visitor_32!(
+    U32Visitor,
+    u32,
+    "a 32-bit unsigned integer in ProtoJSON format"
+);
+
+impl serde_with::SerializeAs<u32> for U32 {
+    fn serialize_as<S>(source: &u32, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u32(*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, 0; "zero as f64")]
+    #[test_case("0", 0; "zero as string")]
+    #[test_case("0.0", 0; "zero as f64 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(u32::MAX, u32::MAX; "max")]
+    #[test_case(u32::MAX as f64, u32::MAX; "max as f64")]
+    #[test_case(format!("{}", u32::MAX), u32::MAX; "max as string")]
+    #[test_case(format!("{}.0", u32::MAX), u32::MAX; "max as f64 string")]
+    // Not quite a roundtrip test because we always serialize as numbers.
+    fn deser_and_ser<T: serde::Serialize>(input: T, want: u32) -> Result<()> {
+        let got = U32::deserialize_as(json!(input))?;
+        assert_eq!(got, want);
+
+        let serialized = U32::serialize_as(&got, serde_json::value::Serializer)?;
+        assert_eq!(serialized, json!(got));
+        Ok(())
+    }
+
+    #[test_case(json!(u64::MAX))]
+    #[test_case(json!(u32::MAX as i64 + 2))]
+    #[test_case(json!(u32::MIN as i64 - 2))]
+    #[test_case(json!(format!("{}", u64::MAX)))]
+    #[test_case(json!("abc"))]
+    #[test_case(json!(123.4))]
+    #[test_case(json!("234.5"))]
+    #[test_case(json!({}))]
+    fn deser_error(input: Value) {
+        let got = U32::deserialize_as(input).unwrap_err();
+        assert!(got.is_data(), "{got:?}");
+    }
+}

src/wkt/src/internal/visitor_32.rs

@@ -0,0 +1,84 @@
+// 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_32 {
+    ($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.
+                // Parse the string 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)),
+                    _ if value > <$t>::MAX 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().abs() > 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 0,
+                    // this conversion is safe.
+                    _ => 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)
+        }
+    };
+}