⚡️ zv,zn,zb,zd,zm: Add zvariant::parsed::Signature & use that in ser/de

.github/workflows/rust.yml

@@ -219,7 +219,7 @@ jobs:
         run: |
           cargo --locked install cargo-fuzz
           cargo --locked fuzz run --fuzz-dir zvariant/fuzz dbus -- -max_total_time=30 -max_len=100M
-          cargo --locked fuzz run --fuzz-dir zvariant/fuzz gvariant -- -max_total_time=30 -max_len=100M
+          cargo --locked fuzz run --fuzz-dir zvariant/fuzz --features gvariant gvariant -- -max_total_time=30 -max_len=100M
 
   doc_build:
     runs-on: ubuntu-latest

zbus/Cargo.toml

@@ -39,33 +39,38 @@ vsock = ["dep:vsock", "dep:async-io"]
 tokio-vsock = ["dep:tokio-vsock", "tokio"]
 
 [dependencies]
-serde = { version = "1.0.200", features = ["derive"] }
-serde_repr = "0.1.19"
+zbus_macros = { path = "../zbus_macros", version = "=4.4.0" }
 zvariant = { path = "../zvariant", version = "4.2.0", default-features = false, features = [
   "enumflags2",
 ] }
 zbus_names = { path = "../zbus_names", version = "3.0" }
-zbus_macros = { path = "../zbus_macros", version = "=4.4.0" }
+serde = { version = "1.0.200", features = ["derive"] }
+serde_repr = "0.1.19"
 enumflags2 = { version = "0.7.9", features = ["serde"] }
-async-io = { version = "2.3.2", optional = true }
 futures-core = "0.3.30"
 futures-sink = "0.3.30"
 futures-util = { version = "0.3.30", default-features = false, features = [
   "sink",
   "std",
 ] }
-async-lock = { version = "3.3.0", optional = true }
 async-broadcast = "0.7.0"
-async-executor = { version = "1.11.0", optional = true }
-blocking = { version = "1.6.0", optional = true }
-async-task = { version = "4.7.1", optional = true }
 hex = "0.4.3"
 ordered-stream = "0.2"
 rand = "0.8.5"
 sha1 = { version = "0.10.6", features = ["std"] }
 event-listener = "5.3.0"
 static_assertions = "1.1.0"
 async-trait = "0.1.80"
+xdg-home = "1.1.0"
+tracing = "0.1.40"
+
+# Optional and target-specific dependencies.
+
+async-io = { version = "2.3.2", optional = true }
+async-lock = { version = "3.3.0", optional = true }
+async-executor = { version = "1.11.0", optional = true }
+blocking = { version = "1.6.0", optional = true }
+async-task = { version = "4.7.1", optional = true }
 async-fs = { version = "2.1.2", optional = true }
 # FIXME: We should only enable process feature for Mac OS. See comment on async-process below for why we can't.
 tokio = { version = "1.37.0", optional = true, features = [
@@ -78,10 +83,8 @@ tokio = { version = "1.37.0", optional = true, features = [
   "sync",
   "tracing",
 ] }
-tracing = "0.1.40"
 vsock = { version = "0.5.0", optional = true }
 tokio-vsock = { version = "0.4", optional = true }
-xdg-home = "1.1.0"
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.59", features = [

zbus/src/message/field.rs

@@ -8,7 +8,7 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use static_assertions::assert_impl_all;
 use zbus_names::{BusName, ErrorName, InterfaceName, MemberName, UniqueName};
-use zvariant::{ObjectPath, Signature, Type, Value};
+use zvariant::{parsed, ObjectPath, Signature, Type, Value};
 
 /// The message field code.
 ///
@@ -97,8 +97,9 @@ pub(crate) enum Field<'f> {
 assert_impl_all!(Field<'_>: Send, Sync, Unpin);
 
 impl<'f> Type for Field<'f> {
-    fn signature() -> Signature<'static> {
-        Signature::from_static_str_unchecked("(yv)")
+    #[inline]
+    fn parsed_signature() -> parsed::Signature {
+        parsed::Signature::static_structure(&[&parsed::Signature::U8, &parsed::Signature::Variant])
     }
 }
 

zbus/src/object_server/mod.rs

@@ -13,7 +13,7 @@ use tracing::{debug, instrument, trace, trace_span, Instrument};
 
 use static_assertions::assert_impl_all;
 use zbus_names::InterfaceName;
-use zvariant::{ObjectPath, OwnedObjectPath, OwnedValue, Signature, Type, Value};
+use zvariant::{parsed::Signature, ObjectPath, OwnedObjectPath, OwnedValue, Type, Value};
 
 use crate::{
     async_lock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
@@ -904,8 +904,9 @@ impl<R> Type for ResponseDispatchNotifier<R>
 where
     R: Type,
 {
-    fn signature() -> Signature<'static> {
-        R::signature()
+    #[inline]
+    fn parsed_signature() -> Signature {
+        R::parsed_signature()
     }
 }
 

zbus_macros/src/proxy.rs

@@ -496,8 +496,9 @@ pub fn create_proxy<M: AttrParse + Into<MethodAttrs>>(
         }
 
         impl<'p> #zbus::zvariant::Type for #proxy_name<'p> {
-            fn signature() -> #zbus::zvariant::Signature<'static> {
-                #zbus::zvariant::OwnedObjectPath::signature()
+            #[inline]
+            fn parsed_signature() -> #zbus::zvariant::parsed::Signature {
+                #zbus::zvariant::parsed::Signature::ObjectPath
             }
         }
 

zbus_names/src/bus_name.rs

@@ -195,8 +195,9 @@ impl<'de: 'name, 'name> Deserialize<'de> for BusName<'name> {
 }
 
 impl Type for BusName<'_> {
-    fn signature() -> zvariant::Signature<'static> {
-        <&str>::signature()
+    #[inline]
+    fn parsed_signature() -> zvariant::parsed::Signature {
+        zvariant::parsed::Signature::Str
     }
 }
 

zbus_names/src/utils.rs

@@ -3,10 +3,6 @@ macro_rules! impl_str_basic {
         impl zvariant::Basic for $type {
             const SIGNATURE_CHAR: char = <zvariant::Str<'_>>::SIGNATURE_CHAR;
             const SIGNATURE_STR: &'static str = <zvariant::Str<'_>>::SIGNATURE_STR;
-
-            fn alignment(format: zvariant::serialized::Format) -> usize {
-                <zvariant::Str<'_>>::alignment(format)
-            }
         }
     };
 }

zvariant/Cargo.toml

@@ -21,13 +21,17 @@ ostree-tests = ["gvariant"]
 option-as-array = []
 
 [dependencies]
+zvariant_derive = { version = "=4.2.0", path = "../zvariant_derive" }
 endi = "1.1.0"
 serde = { version = "1.0.200", features = ["derive"] }
+static_assertions = "1.1.0"
+nom = "7"
+
+# Optional dependencies
+
 arrayvec = { version = "0.7.4", features = ["serde"], optional = true }
 enumflags2 = { version = "0.7.9", features = ["serde"], optional = true }
-zvariant_derive = { version = "=4.2.0", path = "../zvariant_derive" }
 serde_bytes = { version = "0.11.14", optional = true }
-static_assertions = "1.1.0"
 uuid = { version = "1.8.0", features = ["serde"], optional = true }
 url = { version = "2.5.0", features = ["serde"], optional = true }
 time = { version = "0.3.36", features = ["serde"], optional = true }
@@ -59,4 +63,3 @@ all-features = true
 
 [lints]
 workspace = true
-

zvariant/benches/benchmarks.rs

@@ -5,12 +5,10 @@ use std::{collections::HashMap, vec};
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use zvariant::{serialized::Context, to_bytes_for_signature, Type, Value, LE};
+use zvariant::{serialized::Context, to_bytes, Type, Value, LE};
 
 macro_rules! benchmark {
     ($c:ident, $data:ident, $data_type:ty, $func_prefix:literal) => {
-        let signature = <$data_type>::signature();
-
         let ser_function_name = format!("{}_ser", $func_prefix);
         let de_function_name = format!("{}_de", $func_prefix);
 
@@ -20,22 +18,15 @@ macro_rules! benchmark {
         group.measurement_time(std::time::Duration::from_secs(30));
         group.bench_function(&ser_function_name, |b| {
             b.iter(|| {
-                let encoded = to_bytes_for_signature(
-                    black_box(ctxt),
-                    black_box(&signature),
-                    black_box(&$data),
-                )
-                .unwrap();
+                let encoded = to_bytes(black_box(ctxt), black_box(&$data)).unwrap();
                 black_box(encoded);
             })
         });
 
-        let encoded = to_bytes_for_signature(ctxt, &signature, &$data).unwrap();
+        let encoded = to_bytes(ctxt, &$data).unwrap();
         group.bench_function(&de_function_name, |b| {
             b.iter(|| {
-                let (s, _): ($data_type, _) = encoded
-                    .deserialize_for_signature(black_box(&signature))
-                    .unwrap();
+                let (s, _): ($data_type, _) = encoded.deserialize().unwrap();
                 black_box(s);
             })
         });
@@ -50,22 +41,15 @@ macro_rules! benchmark {
 
             group.bench_function(&ser_function_name, |b| {
                 b.iter(|| {
-                    let encoded = to_bytes_for_signature(
-                        black_box(ctxt),
-                        black_box(&signature),
-                        black_box(&$data),
-                    )
-                    .unwrap();
+                    let encoded = to_bytes(black_box(ctxt), black_box(&$data)).unwrap();
                     black_box(encoded);
                 })
             });
 
-            let encoded = to_bytes_for_signature(ctxt, &signature, &$data).unwrap();
+            let encoded = to_bytes(ctxt, &$data).unwrap();
             group.bench_function(&de_function_name, |b| {
                 b.iter(|| {
-                    let (s, _): ($data_type, _) = encoded
-                        .deserialize_for_signature(black_box(&signature))
-                        .unwrap();
+                    let (s, _): ($data_type, _) = encoded.deserialize().unwrap();
                     black_box(s);
                 })
             });

zvariant/fuzz/Cargo.toml

@@ -7,13 +7,18 @@ edition = "2021"
 [package.metadata]
 cargo-fuzz = true
 
+[features]
+# `gvariant` is only needed for the `gvariant` fuzz target. However, we don't want it to
+# be enabled for running the `dbus` fuzz target, as that can cause certain assertions to fail.
+# FIXME: Is there a better way to do this?
+gvariant = ["zvariant/gvariant"]
+
 [dependencies]
 libfuzzer-sys = "0.4.7"
 endi = "1.1.0"
 
 [dependencies.zvariant]
 path = ".."
-features = ["gvariant"]
 
 # Prevent this from interfering with workspaces
 [workspace]