Flattening fields is not zero-cost in serde

Cargo.toml

[package]
name = "serdebug"
version = "0.1.0"
edition = "2018"

[dependencies]
serde = { version = "1.0.91", features = ["derive"] }
serde_json = "1.0.39"

lib.rs

#![feature(test)]
use serde::Deserialize;
extern crate test;

#[derive(Debug, PartialEq, Deserialize)]
struct AlreadyFlat {
    b: bool,
    i: i32,
    f: f64,
}

#[derive(Debug, PartialEq, Deserialize)]
struct NestedAndFlattened {
    b: bool,
    #[serde(flatten)]
    inner: Inner,
    f: f64,
}

#[derive(Debug, PartialEq, Deserialize)]
struct Inner {
    i: i32,
}

impl From<AlreadyFlat> for NestedAndFlattened {
    fn from(already: AlreadyFlat) -> Self {
        NestedAndFlattened {
            b: already.b,
            inner: Inner { i: already.i },
            f: already.f,
        }
    }
}

#[cfg(test)]
mod benches {
    use super::*;
    use test::{Bencher, black_box};

    #[bench]
    fn deserialize_to_flat(b: &mut Bencher) {
        let s = r#"{ "b": false, "i": 1000, "f": -2 }"#;
        b.iter(|| {
            let a: AlreadyFlat = serde_json::from_str(s).unwrap();
            black_box(&a);
        });
    }

    #[bench]
    fn deserialize_to_nested_and_flattened(b: &mut Bencher) {
        let s = r#"{ "b": false, "i": 1000, "f": -2 }"#;
        b.iter(|| {
            let a: NestedAndFlattened = serde_json::from_str(s).unwrap();
            black_box(&a);
        });
    }
    
    #[bench]
    fn deserialize_to_flat_and_then_convert_to_nested(b: &mut Bencher) {
        let s = r#"{ "b": false, "i": 1000, "f": -2 }"#;
        b.iter(|| {
            let flat: AlreadyFlat = serde_json::from_str(s).unwrap();
            let a: NestedAndFlattened = flat.into();
            black_box(&a);
        });
    }
}

output.txt

running 3 tests

test benches::deserialize_to_flat                            ... bench:          85 ns/iter (+/- 2)
test benches::deserialize_to_flat_and_then_convert_to_nested ... bench:          85 ns/iter (+/- 6)
test benches::deserialize_to_nested_and_flattened            ... bench:         225 ns/iter (+/- 24)