serde_as cannot be cfg-gated

[chipsenkbeil]

I've seen some examples of using serde_as for explicitly-defined size ranges, but I'm struggling to figure out how to apply to const generics, if it's even possible.

use serde::{Serialize, Deserialize};
use serde_with::serde_as;

#[serde_as]
#[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct FixedMatrix<T, const ROW: usize, const COL: usize> {
    #[serde_as(as = "[[_; ROW]; COL]")]
    data: [[T; ROW]; COL],
}

Was browsing through serde-rs/serde#1937 and saw mention of:

#[serde_with::serde_as]
#[derive(Serialize)]
struct Foo {
    #[serde_as(as = "[_; 2]")]
    bar: [String; 2],
    #[serde_as(as = "Vec<[_; 5]>")]
    foobar: Vec<[u8; 5]>,
}

[jonasbb]

Since you use serde_as on a field with a generic, you need to manually specify the correct trait bounds for de-/serializing type T.

use serde::{Serialize, Deserialize};
use serde_with::serde_as;

#[serde_as]
#[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(serialize = "T: Serialize", deserialize = "T: Deserialize<'de>"))]
struct FixedMatrix<T, const ROW: usize, const COL: usize> {
    #[serde_as(as = "[[_; ROW]; COL]")]
    data: [[T; ROW]; COL],
}

Applying any of the serde attributes with, serialize_with, or deserialize_with on generics changes how serde infers the trait bounds of the resulting implementations. By default, serde adds T: Serialize as a requirement to the Serialize implementation, but not if those attributes are specified.

The same applies to serde_as. You need to tell serde that T can be de-/serialized by specifying the correct trait bounds. Then it will compile without problems.

---

Your attribute would work as is, if a normal type is used in the array, e.g., [[u8; ROW]; COL].

#[serde_as(as = "[[_; ROW]; COL]")]
data: [[u8; ROW]; COL],

[jonasbb]

@chipsenkbeil Good to hear that you found a solution. One note about your implementation: the #[serde(bound( ... ))] part needs to be on the struct/enum, not on the fields.

I think I found the problem. You are cfg-gating the serde_as field attribute. This cfg_attr is still present when the serde_as proc-macro gets run. The proc-macro does not recognize the cfg_attr and simply ignores it. When the serde derives run, they do not see any attributes on the field and fail to serialize it, due to missing const generics support.

I don't think it is currently possible to eagerly expand cfg_attr in a proc-macro, since IIRC the expansion order is proc-macros, cfg_attr, derive-macros.
It could be solved by distributing a set of serde_derive like macros which directly understand the serde_as syntax.

---

I noticed your serialize_table_array does something different from [[T; COL]; ROW], namely it serializes into a single sequence, but the arrays are multiple nested sequences. Using serde_with will not help here.

[chipsenkbeil]

@jonasbb I just flattened it because that seemed simpler to do, not that I require it to be done that way in practice. :)

What's interesting is that I'm able to use the cfg-gating for another struct with a HashMap<_, T>. But you're right in that after you mentioned that I'm surprised it worked.

[jonasbb]

Have you tried running that piece of code? It will compile if Position position is serializable. But it will try to serialize it as a HashMap not as a list of tuples.

[chipsenkbeil]

@jonasbb I've not written any test to verify that serde serialization/deserialization of the table works. It's something I should do as I was bitten by the HashMap with custom key when serializing to serde_json in the past. It's how I found your fantastic library 😄

Cleaning up some parts of the library today, so I'll get around to testing it and seeing what happens. All I know so far is that it compiles w/ and w/o serde being incorporated, to my knowledge.

[jonasbb]

There is some work in rustc to have a #[cfg_eval] attribute, which will eagerly evaluate all cfgs before the proc macros. There is a tracking issue rust-lang/rust#82679 and a stabilization PR rust-lang/rust#83824.

It might be possible for serde_as to see through the cfg_attr and still do all the serde_as transformations. Basically, transform #[cfg_attr(foobar, serde_as(as = "..."))] into #[cfg_attr(foobar, serde(with = "..."))].