fix: close remaining 0.1.0 release gaps (#15)

Signed-off-by: tison <wander4096@gmail.com>

Author: tisonkun

CHANGELOG.md

@@ -40,18 +40,19 @@ All notable changes to this project will be documented in this file.
 
 ### Bug fixes
 
-* Match Serde's fixed-array coverage and bounds: lengths above 32 no longer claim shape support, while zero-length arrays no longer require their unobserved element type to implement a shape trait.
+* Preserve qualified Serde function paths such as `<T as Trait>::function` as parseable Rust token streams.
+* Match Serde's fixed-array coverage and bounds: lengths above 32 no longer claim shape support, while zero-length arrays no longer require their unobserved element type to implement a shape trait, including inside derived generic containers.
 * Match Serde's deserialization bounds for tree and hash collections so a shape implementation is exposed only when the corresponding collection can actually deserialize.
 * Preserve the known string and byte shapes of `#[serde(borrow)]` fields using `Cow<str>` or `Cow<[u8]>` from their source-level metadata, while leaving explicit custom deserializers opaque.
 * Distinguish borrowed byte input from owned boxed slices: `&[u8]` reflects bytes while `Box<[u8]>` reflects a sequence, matching Serde.
 * Match Serde's serialization bounds for `BinaryHeap`, `RefCell`, `Mutex`, and `RwLock`, including unsized wrapper contents.
 * Reflect the proxy type used by Serde `from`, `try_from`, and `into` container attributes.
 * Follow Serde's directional bounds for `Cow`: serialization reflects the borrowed type and deserialization reflects the owned type.
 * Make IP and socket address shapes available in `no_std` builds through `core::net`.
-* Preserve qualified Serde default paths without token-rendering spaces.
 
 ### Improvements
 
+* Point README and crate-level installation examples at the upcoming `0.1.0` release.
 * State the graph-local `ShapeId` ownership contract accurately instead of claiming that lookups can detect an in-bounds id copied from another graph.
 * Add `definition_for` to both graph types so walkers can resolve a `ShapeRef::Definition` without repeating a match and id lookup.
 * Verify the packaged main crate against the packaged derive implementation that will be released with it, rather than accidentally compiling the previously published same-version macro crate from crates.io.

Cargo.lock

@@ -26,14 +26,14 @@ Enable the `derive` feature when you want `#[derive(SerializeShape)]` and `#[der
 
 ```toml
 [dependencies]
-serde-shape = { version = "0.0.1", features = ["derive"] }
+serde-shape = { version = "0.1.0", features = ["derive"] }
 ```
 
 Enable `std` when your reflected types use shapes provided only by the Rust standard library:
 
 ```toml
 [dependencies]
-serde-shape = { version = "0.0.1", features = ["derive", "std"] }
+serde-shape = { version = "0.1.0", features = ["derive", "std"] }
 ```
 
 ## Motivation

README.md

@@ -368,8 +368,15 @@ fn collect_shape_bound_types(
     type_params: &BTreeSet<String>,
     field_bound_types: &mut Vec<Type>,
 ) {
+    // Keep this selective traversal aligned with serde_derive::bound::with_bound. A general
+    // syn::visit::Visit would also enter macros and const expressions, where mentioning a type
+    // parameter does not imply that the field needs a Shape bound.
     match ty {
-        Type::Array(ty) => collect_shape_bound_types(&ty.elem, type_params, field_bound_types),
+        Type::Array(ty) => {
+            if !is_zero_length(&ty.len) {
+                collect_shape_bound_types(&ty.elem, type_params, field_bound_types);
+            }
+        }
         Type::FnPtr(ty) => {
             for input in &ty.inputs {
                 collect_shape_bound_types(&input.ty, type_params, field_bound_types);
@@ -445,6 +452,19 @@ fn collect_shape_bound_types(
     }
 }
 
+fn is_zero_length(expr: &syn::Expr) -> bool {
+    match expr {
+        syn::Expr::Group(expr) => is_zero_length(&expr.expr),
+        syn::Expr::Lit(expr) => {
+            matches!(&expr.lit, syn::Lit::Int(value) if value
+                .base10_parse::<usize>()
+                .is_ok_and(|value| value == 0))
+        }
+        syn::Expr::Paren(expr) => is_zero_length(&expr.expr),
+        _ => false,
+    }
+}
+
 fn type_uses_params(ty: &Type, type_params: &BTreeSet<String>) -> bool {
     let mut bound_types = Vec::new();
     collect_shape_bound_types(ty, type_params, &mut bound_types);
@@ -931,7 +951,7 @@ fn default_shape(default: &attr::Default) -> TokenStream2 {
         attr::Default::None => quote!(__serde_shape::DefaultShape::None),
         attr::Default::Default => quote!(__serde_shape::DefaultShape::Default),
         attr::Default::Path(path) => {
-            let path = lit(path.to_token_stream().to_string().replace(' ', ""));
+            let path = lit(path.to_token_stream().to_string());
             quote!(__serde_shape::DefaultShape::Path(#path))
         }
     }
@@ -1033,7 +1053,7 @@ fn option_lit(value: Option<&str>) -> TokenStream2 {
 fn option_path(value: Option<&syn::ExprPath>) -> TokenStream2 {
     match value {
         Some(value) => {
-            let value = lit(value.to_token_stream().to_string().replace(' ', ""));
+            let value = lit(value.to_token_stream().to_string());
             quote!(::core::option::Option::Some(#value))
         }
         None => quote!(::core::option::Option::None),

serde-shape-derive/src/lib.rs

@@ -30,14 +30,14 @@
 //!
 //! ```toml
 //! [dependencies]
-//! serde-shape = { version = "0.0.1", features = ["derive"] }
+//! serde-shape = { version = "0.1.0", features = ["derive"] }
 //! ```
 //!
 //! Enable `std` when the reflected types use shapes provided only by the Rust standard library:
 //!
 //! ```toml
 //! [dependencies]
-//! serde-shape = { version = "0.0.1", features = ["derive", "std"] }
+//! serde-shape = { version = "0.1.0", features = ["derive", "std"] }
 //! ```
 //!
 //! The crate is `no_std` by default and requires `alloc`.
@@ -293,7 +293,7 @@ pub use serde_shape_derive::DeserializeShape;
 /// assert_eq!(definition.type_name.name, "api-response");
 /// assert_eq!(shape.fields[0].name, "requestId");
 /// assert_eq!(shape.fields[1].name, "nextPage");
-/// assert_eq!(shape.fields[1].skip_if, Some("Option::is_none"));
+/// assert!(shape.fields[1].skip_if.is_some());
 /// ```
 pub use serde_shape_derive::SerializeShape;
 
@@ -987,7 +987,8 @@ pub struct SerializeFieldShape {
     pub description: Option<&'static str>,
     /// How this field contributes to the serialized wire shape.
     pub wire_shape: FieldWireShape,
-    /// The predicate used to skip this field during serialization.
+    /// The predicate used to skip this field during serialization, rendered as a parseable Rust
+    /// path token stream. Whitespace is not normalized.
     pub skip_if: Option<&'static str>,
 }
 
@@ -1120,7 +1121,8 @@ pub enum DefaultShape {
     None,
     /// `Default::default()` is used.
     Default,
-    /// A custom default function path is used.
+    /// A custom default function path is used. The value is a parseable Rust path token stream;
+    /// whitespace is not normalized.
     Path(&'static str),
 }
 
@@ -1145,9 +1147,11 @@ pub struct OpaqueShape {
 /// Reason a shape cannot be represented precisely.
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub enum OpaqueReason {
-    /// A custom serializer controls the output.
+    /// A custom serializer controls the output. Derive-generated `detail` is a parseable Rust path
+    /// token stream whose whitespace is not normalized.
     CustomSerializer,
-    /// A custom deserializer controls the input.
+    /// A custom deserializer controls the input. Derive-generated `detail` is a parseable Rust
+    /// path token stream whose whitespace is not normalized.
     CustomDeserializer,
     /// The type has no built-in shape implementation.
     Unsupported,

serde-shape/src/lib.rs

@@ -30,6 +30,7 @@ renamed-shape = { package = "serde-shape", path = "../../serde-shape", features
 [dev-dependencies]
 serde = { workspace = true }
 serde_json = { workspace = true }
+syn = { workspace = true }
 
 [lints]
 workspace = true

tests/derive/Cargo.toml

@@ -188,6 +188,17 @@ struct Marker<T> {
     marker: core::marker::PhantomData<T>,
 }
 
+#[derive(SerializeShape, DeserializeShape)]
+struct EmptyArray<T> {
+    values: [T; 0],
+}
+
+#[derive(DeserializeShape)]
+struct QualifiedMetadataPaths {
+    #[serde(default = "<u8 as Default>::default")]
+    value: u8,
+}
+
 #[derive(serde::Deserialize, DeserializeShape)]
 struct BorrowedCow<'a> {
     #[serde(borrow)]
@@ -308,6 +319,10 @@ fn deserialize_bool_shape(_context: &mut DeserializeShapeContext) -> ShapeRef {
     ShapeRef::Bool
 }
 
+fn parse_path(path: &str) -> syn::ExprPath {
+    syn::parse_str(path).expect("metadata path should remain valid Rust")
+}
+
 fn deserialize_borrowed_str<'de, D>(deserializer: D) -> Result<Cow<'de, str>, D::Error>
 where
     D: serde::Deserializer<'de>,
@@ -335,9 +350,18 @@ fn exposes_deserialize_container_attributes() {
     };
     assert_eq!(http_port.name, "http-port");
     assert_eq!(api_url.aliases, ["api-url", "endpoint"]);
+    let DefaultShape::Path(path) = retries.default else {
+        panic!("custom default should be represented by its path");
+    };
+    let path = parse_path(path);
+    assert!(path.qself.is_none());
     assert_eq!(
-        retries.default,
-        DefaultShape::Path("crate::default_retries")
+        path.path
+            .segments
+            .iter()
+            .map(|segment| segment.ident.to_string())
+            .collect::<Vec<_>>(),
+        ["crate", "default_retries"]
     );
     assert!(matches!(storage.wire_shape, FieldWireShape::Flatten(_)));
     assert_eq!(skipped.wire_shape, FieldWireShape::Omitted);
@@ -521,7 +545,7 @@ fn preserves_rust_documentation() {
 }
 
 #[test]
-fn omits_shape_bounds_for_skipped_and_marker_fields() {
+fn omits_unnecessary_shape_bounds() {
     assert_eq!(
         SkipsGeneric::<NotShape>::deserialize_shape()
             .definitions()
@@ -532,6 +556,39 @@ fn omits_shape_bounds_for_skipped_and_marker_fields() {
         Marker::<NotShape>::deserialize_shape().definitions().len(),
         1
     );
+    assert_eq!(
+        EmptyArray::<NotShape>::serialize_shape()
+            .definitions()
+            .len(),
+        1
+    );
+    assert_eq!(
+        EmptyArray::<NotShape>::deserialize_shape()
+            .definitions()
+            .len(),
+        1
+    );
+}
+
+#[test]
+fn preserves_qualified_metadata_paths() {
+    let deserialize = deserialize_root_definition::<QualifiedMetadataPaths>();
+    let DeserializeDefinitionKind::Struct(deserialize) = &deserialize.kind else {
+        panic!("deserialization definition should be a struct");
+    };
+    let DefaultShape::Path(path) = deserialize.fields[0].default else {
+        panic!("qualified default should be represented by its path");
+    };
+    let path = parse_path(path);
+    assert!(path.qself.is_some());
+    assert_eq!(
+        path.path
+            .segments
+            .iter()
+            .map(|segment| segment.ident.to_string())
+            .collect::<Vec<_>>(),
+        ["Default", "default"]
+    );
 }
 
 #[test]

tests/derive/tests/derive.rs

@@ -85,6 +85,19 @@ fn flat_value_shape() -> ShapeRef {
     }
 }
 
+fn assert_path(actual: Option<&str>, expected_segments: &[&str]) {
+    let path = syn::parse_str::<syn::ExprPath>(actual.expect("path metadata should be present"))
+        .expect("metadata path should remain valid Rust");
+    assert_eq!(
+        path.path
+            .segments
+            .iter()
+            .map(|segment| segment.ident.to_string())
+            .collect::<Vec<_>>(),
+        expected_segments
+    );
+}
+
 #[test]
 fn composes_flatten_with_custom_field_boundaries() {
     let value = FlattenedCustom {
@@ -102,14 +115,14 @@ fn composes_flatten_with_custom_field_boundaries() {
         panic!("custom serialized flatten field should be flattened and opaque");
     };
     assert_eq!(opaque.reason, OpaqueReason::CustomSerializer);
-    assert_eq!(opaque.detail, Some("flat_value::serialize"));
+    assert_path(opaque.detail, &["flat_value", "serialize"]);
 
     let deserialize_field = first_deserialize_field::<FlattenedCustom>();
     let FieldWireShape::Flatten(ShapeRef::Opaque(opaque)) = deserialize_field.wire_shape else {
         panic!("custom deserialized flatten field should be flattened and opaque");
     };
     assert_eq!(opaque.reason, OpaqueReason::CustomDeserializer);
-    assert_eq!(opaque.detail, Some("flat_value::deserialize"));
+    assert_path(opaque.detail, &["flat_value", "deserialize"]);
 }
 
 #[test]
@@ -147,14 +160,14 @@ fn composes_transparent_with_custom_field_boundaries() {
         panic!("custom serialized transparent field should be inline and opaque");
     };
     assert_eq!(opaque.reason, OpaqueReason::CustomSerializer);
-    assert_eq!(opaque.detail, Some("stringified::serialize"));
+    assert_path(opaque.detail, &["stringified", "serialize"]);
 
     let deserialize_field = first_deserialize_field::<TransparentCustom>();
     let FieldWireShape::Inline(ShapeRef::Opaque(opaque)) = deserialize_field.wire_shape else {
         panic!("custom deserialized transparent field should be inline and opaque");
     };
     assert_eq!(opaque.reason, OpaqueReason::CustomDeserializer);
-    assert_eq!(opaque.detail, Some("stringified::deserialize"));
+    assert_path(opaque.detail, &["stringified", "deserialize"]);
 }
 
 #[test]
@@ -172,14 +185,14 @@ fn retains_custom_variant_boundary_details() {
         panic!("custom serialized variant should expose opaque content");
     };
     assert_eq!(opaque.reason, OpaqueReason::CustomSerializer);
-    assert_eq!(opaque.detail, Some("stringified::serialize"));
+    assert_path(opaque.detail, &["stringified", "serialize"]);
 
     let deserialize_variant = first_deserialize_variant::<CustomVariant>();
     let DeserializeVariantContent::Custom(opaque) = deserialize_variant.content else {
         panic!("custom deserialized variant should expose opaque content");
     };
     assert_eq!(opaque.reason, OpaqueReason::CustomDeserializer);
-    assert_eq!(opaque.detail, Some("stringified::deserialize"));
+    assert_path(opaque.detail, &["stringified", "deserialize"]);
 }
 
 #[test]