2026-10-03
\n-\n \n rust\n
\nIn Rust, one of the most common ways to implement core traits (like\nDebug, Display, and Clone) is to #[derive(...)] them, e.g.:
#[derive(Debug)]\nstruct Widgets {\n foo: u32,\n bar: usize,\n}\nWhat I didn't know until recently is that Rust currently emits\n#[inline] as part of these derivations. This is seemingly\nnot guaranteed, but is implied by example in the reference\nand can also be seen if one expands the macros.
Using the example above, this is what you get when you expand\nthe #[derive(Debug)] in the playground:
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}\nThis is almost always what we want: #[inline] is just a hint,\nand typical derived Debug, Clone, etc. implementations benefit\nfrom being inlined (since they're often trivial).
But not always! Imagine an error hierarchy like this[1]:
\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}\nproduces:
\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#[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}\nThat's a lot of code that can get inlined for each invocation of the Debug\nimplementation of Errors, which can occur repeatedly in e.g. debug or trace logging.
In fact, it's so much code that it can turn out to be a non-trivial amount of a Rust\nbinary's total size: we found that we could shrink uv's binary size by approximately\n160KB by preventing[2] rustc from inlining a given Debug implementation.
This was surprising to me on two levels: the size cost added up fast, and rustc\n(seemingly) did not apply a limit to the size or number of times a Debug implementation\nwas inlined. I suspect this is the right decision in many programs, however!
-
\nThis hierarchy is drastically simplified: real world Rust applications often have\ndeeply nested error enumerations with nontrivial numbers of fields. [↩]
\n-
\nWe did this by adding our own-proc macro that behaves like derive(Debug), but\nwith #[inline(never)]. [↩]