{ "description": "Browse aymeric's, an independent, searchable archive of readable snapshots from followed feeds, preserved in Git with aggr.", "feed_url": "https://aggr.aymericbeaumet.com/sources/yossarian.net/feed.json", "home_page_url": "https://aggr.aymericbeaumet.com/sources/yossarian.net/", "items": [ { "authors": [ { "name": "yossarian.net by yossarian" } ], "content_html": "

In Rust, one of the most common ways to implement core traits (like Debug, Display, and Clone) is to #[derive(...)] them, e.g.:

\n
#[derive(Debug)]\nstruct Widgets {\n  foo: u32,\n  bar: usize,\n}\n
\n

What I didn't know until recently is that Rust currently emits #[inline] as part of these derivations. This is seemingly not guaranteed, but is implied by example in the reference and can also be seen if one expands the macros.

\n

Using the example above, this is what you get when you expand the #[derive(Debug)] in the playground:

\n
struct Widgets {\n    foo: u32,\n    bar: usize,\n}\n#[automatically_derived]\nimpl ::core::fmt::Debug for Widgets {\n    #[inline]\n    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {\n        ::core::fmt::Formatter::debug_struct_field2_finish(f, "Widgets",\n            "foo", &self.foo, "bar", &&self.bar)\n    }\n}\n
\n

This is almost always what we want: #[inline] is just a hint, and typical derived Debug, Clone, etc. implementations benefit from being inlined (since they're often trivial).

\n

But not always! Imagine an error hierarchy like this1:

\n
#[derive(Debug)]\nstruct ErrorA {\n  lots: String,\n  of: String,\n  chunky: String,\n  fields: String,\n  within: String,\n  this: String,\n  r#type: String,\n}\n\n#[derive(Debug)]\nstruct ErrorB {\n  inner: ErrorA,\n}\n\n#[derive(Debug)]\nstruct ErrorC {\n  inner: ErrorB,\n}\n\n#[derive(Debug)]\nenum Errors {\n    A(ErrorA),\n    B(ErrorB),\n    C(ErrorC),\n}\n
\n

produces:

\n
struct ErrorA {\n    lots: String,\n    of: String,\n    chunky: String,\n    fields: String,\n    within: String,\n    this: String,\n    r#type: String,\n}\n#[automatically_derived]\nimpl ::core::fmt::Debug for ErrorA {\n    #[inline]\n    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {\n        let names: &'static _ =\n            &["lots", "of", "chunky", "fields", "within", "this", "type"];\n        let values: &[&dyn ::core::fmt::Debug] =\n            &[&self.lots, &self.of, &self.chunky, &self.fields, &self.within,\n                        &self.this, &&self.r#type];\n        ::core::fmt::Formatter::debug_struct_fields_finish(f, "ErrorA", names,\n            values)\n    }\n}\n#[automatically_derived]\nimpl ::core::default::Default for ErrorA {\n    #[inline]\n    fn default() -> Self {\n        Self {\n            lots: ::core::default::Default::default(),\n            of: ::core::default::Default::default(),\n            chunky: ::core::default::Default::default(),\n            fields: ::core::default::Default::default(),\n            within: ::core::default::Default::default(),\n            this: ::core::default::Default::default(),\n            r#type: ::core::default::Default::default(),\n        }\n    }\n}\n\nstruct ErrorB {\n    inner: ErrorA,\n}\n#[automatically_derived]\nimpl ::core::fmt::Debug for ErrorB {\n    #[inline]\n    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {\n        ::core::fmt::Formatter::debug_struct_field1_finish(f, "ErrorB",\n            "inner", &&self.inner)\n    }\n}\n\nstruct ErrorC {\n    inner: ErrorB,\n}\n#[automatically_derived]\nimpl ::core::fmt::Debug for ErrorC {\n    #[inline]\n    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {\n        ::core::fmt::Formatter::debug_struct_field1_finish(f, "ErrorC",\n            "inner", &&self.inner)\n    }\n}\n\nenum Errors { A(ErrorA), B(ErrorB), C(ErrorC), }\n#[automatically_derived]\nimpl ::core::fmt::Debug for Errors {\n    #[inline]\n    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {\n        match self {\n            Self::A(__self_0) =>\n                ::core::fmt::Formatter::debug_tuple_field1_finish(f, "A",\n                    &__self_0),\n            Self::B(__self_0) =>\n                ::core::fmt::Formatter::debug_tuple_field1_finish(f, "B",\n                    &__self_0),\n            Self::C(__self_0) =>\n                ::core::fmt::Formatter::debug_tuple_field1_finish(f, "C",\n                    &__self_0),\n        }\n    }\n}\n
\n

That's a lot of code that can get inlined for each invocation of the Debug implementation of Errors, which can occur repeatedly in e.g. debug or trace logging.

\n

In fact, it's so much code that it can turn out to be a non-trivial amount of a Rust binary's total size: we found that we could shrink uv's binary size by approximately 160KB by preventing2 rustc from inlining a given Debug implementation.

\n

This was surprising to me on two levels: the size cost added up fast, and rustc (seemingly) did not apply a limit to the size or number of times a Debug implementation was inlined. I suspect this is the right decision in many programs, however!

\n
\n
    \n
  1. \n

    This hierarchy is drastically simplified: real world Rust applications often have deeply nested error enumerations with nontrivial numbers of fields. ↩

    \n
    2. \n
  2. \n

    We did this by adding our own-proc macro that behaves like derive(Debug), but with #[inline(never)]. ↩

    \n
    3. \n
\n
\n", "date_modified": "2026-10-04T01:41:57+00:00", "date_published": "2026-10-04T01:41:57+00:00", "external_url": "https://yossarian.net/til/post/rust-s-derive-often-implies-inline/", "id": "urn:aggr:item:dd1c835e931fd75b964ec0f8f529f09f6b94296c", "summary": "Comments", "tags": [ "news", "rust" ], "title": "Rust's derive often implies inline", "url": "https://aggr.aymericbeaumet.com/items/lobste-rs/2026-10-04-rust-s-derive-often-implies-inline/" } ], "language": "en", "title": "yossarian.net", "version": "https://jsonfeed.org/version/1.1" }