Skip to content

Commit 374142e

Browse files
borsbors
committed
Auto merge of #98190 - nnethercote:optimize-derive-Debug-code, r=scottmcm
Improve `derive(Debug)` r? `@ghost`
2 parents 6ba559c + ac64bb7 commit 374142e

File tree

1 file changed

+227
-1
lines changed

1 file changed

+227
-1
lines changed

‎core/src/fmt/mod.rs

Lines changed: 227 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44

55
use crate::cell::{Cell, Ref, RefCell, RefMut, SyncUnsafeCell, UnsafeCell};
66
use crate::char::EscapeDebugExtArgs;
7+
use crate::iter;
78
use crate::marker::PhantomData;
89
use crate::mem;
910
use crate::num::fmt as numfmt;
@@ -693,7 +694,7 @@ pub(crate) mod macros {
693694
/// Derive macro generating an impl of the trait `Debug`.
694695
#[rustc_builtin_macro]
695696
#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
696-
#[allow_internal_unstable(core_intrinsics)]
697+
#[allow_internal_unstable(core_intrinsics, fmt_helpers_for_derive)]
697698
pub macro Debug($item:item) {
698699
/* compiler built-in */
699700
}
@@ -1964,6 +1965,129 @@ impl<'a> Formatter<'a> {
19641965
builders::debug_struct_new(self, name)
19651966
}
19661967

1968+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
1969+
/// `debug_struct_fields_finish` is more general, but this is faster for 1 field.
1970+
#[doc(hidden)]
1971+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
1972+
pub fn debug_struct_field1_finish<'b>(
1973+
&'b mut self,
1974+
name: &str,
1975+
name1: &str,
1976+
value1: &dyn Debug,
1977+
) -> Result {
1978+
let mut builder = builders::debug_struct_new(self, name);
1979+
builder.field(name1, value1);
1980+
builder.finish()
1981+
}
1982+
1983+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
1984+
/// `debug_struct_fields_finish` is more general, but this is faster for 2 fields.
1985+
#[doc(hidden)]
1986+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
1987+
pub fn debug_struct_field2_finish<'b>(
1988+
&'b mut self,
1989+
name: &str,
1990+
name1: &str,
1991+
value1: &dyn Debug,
1992+
name2: &str,
1993+
value2: &dyn Debug,
1994+
) -> Result {
1995+
let mut builder = builders::debug_struct_new(self, name);
1996+
builder.field(name1, value1);
1997+
builder.field(name2, value2);
1998+
builder.finish()
1999+
}
2000+
2001+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2002+
/// `debug_struct_fields_finish` is more general, but this is faster for 3 fields.
2003+
#[doc(hidden)]
2004+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2005+
pub fn debug_struct_field3_finish<'b>(
2006+
&'b mut self,
2007+
name: &str,
2008+
name1: &str,
2009+
value1: &dyn Debug,
2010+
name2: &str,
2011+
value2: &dyn Debug,
2012+
name3: &str,
2013+
value3: &dyn Debug,
2014+
) -> Result {
2015+
let mut builder = builders::debug_struct_new(self, name);
2016+
builder.field(name1, value1);
2017+
builder.field(name2, value2);
2018+
builder.field(name3, value3);
2019+
builder.finish()
2020+
}
2021+
2022+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2023+
/// `debug_struct_fields_finish` is more general, but this is faster for 4 fields.
2024+
#[doc(hidden)]
2025+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2026+
pub fn debug_struct_field4_finish<'b>(
2027+
&'b mut self,
2028+
name: &str,
2029+
name1: &str,
2030+
value1: &dyn Debug,
2031+
name2: &str,
2032+
value2: &dyn Debug,
2033+
name3: &str,
2034+
value3: &dyn Debug,
2035+
name4: &str,
2036+
value4: &dyn Debug,
2037+
) -> Result {
2038+
let mut builder = builders::debug_struct_new(self, name);
2039+
builder.field(name1, value1);
2040+
builder.field(name2, value2);
2041+
builder.field(name3, value3);
2042+
builder.field(name4, value4);
2043+
builder.finish()
2044+
}
2045+
2046+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2047+
/// `debug_struct_fields_finish` is more general, but this is faster for 5 fields.
2048+
#[doc(hidden)]
2049+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2050+
pub fn debug_struct_field5_finish<'b>(
2051+
&'b mut self,
2052+
name: &str,
2053+
name1: &str,
2054+
value1: &dyn Debug,
2055+
name2: &str,
2056+
value2: &dyn Debug,
2057+
name3: &str,
2058+
value3: &dyn Debug,
2059+
name4: &str,
2060+
value4: &dyn Debug,
2061+
name5: &str,
2062+
value5: &dyn Debug,
2063+
) -> Result {
2064+
let mut builder = builders::debug_struct_new(self, name);
2065+
builder.field(name1, value1);
2066+
builder.field(name2, value2);
2067+
builder.field(name3, value3);
2068+
builder.field(name4, value4);
2069+
builder.field(name5, value5);
2070+
builder.finish()
2071+
}
2072+
2073+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2074+
/// For the cases not covered by `debug_struct_field[12345]_finish`.
2075+
#[doc(hidden)]
2076+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2077+
pub fn debug_struct_fields_finish<'b>(
2078+
&'b mut self,
2079+
name: &str,
2080+
names: &[&str],
2081+
values: &[&dyn Debug],
2082+
) -> Result {
2083+
assert_eq!(names.len(), values.len());
2084+
let mut builder = builders::debug_struct_new(self, name);
2085+
for (name, value) in iter::zip(names, values) {
2086+
builder.field(name, value);
2087+
}
2088+
builder.finish()
2089+
}
2090+
19672091
/// Creates a `DebugTuple` builder designed to assist with creation of
19682092
/// `fmt::Debug` implementations for tuple structs.
19692093
///
@@ -1995,6 +2119,108 @@ impl<'a> Formatter<'a> {
19952119
builders::debug_tuple_new(self, name)
19962120
}
19972121

2122+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2123+
/// `debug_tuple_fields_finish` is more general, but this is faster for 1 field.
2124+
#[doc(hidden)]
2125+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2126+
pub fn debug_tuple_field1_finish<'b>(&'b mut self, name: &str, value1: &dyn Debug) -> Result {
2127+
let mut builder = builders::debug_tuple_new(self, name);
2128+
builder.field(value1);
2129+
builder.finish()
2130+
}
2131+
2132+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2133+
/// `debug_tuple_fields_finish` is more general, but this is faster for 2 fields.
2134+
#[doc(hidden)]
2135+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2136+
pub fn debug_tuple_field2_finish<'b>(
2137+
&'b mut self,
2138+
name: &str,
2139+
value1: &dyn Debug,
2140+
value2: &dyn Debug,
2141+
) -> Result {
2142+
let mut builder = builders::debug_tuple_new(self, name);
2143+
builder.field(value1);
2144+
builder.field(value2);
2145+
builder.finish()
2146+
}
2147+
2148+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2149+
/// `debug_tuple_fields_finish` is more general, but this is faster for 3 fields.
2150+
#[doc(hidden)]
2151+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2152+
pub fn debug_tuple_field3_finish<'b>(
2153+
&'b mut self,
2154+
name: &str,
2155+
value1: &dyn Debug,
2156+
value2: &dyn Debug,
2157+
value3: &dyn Debug,
2158+
) -> Result {
2159+
let mut builder = builders::debug_tuple_new(self, name);
2160+
builder.field(value1);
2161+
builder.field(value2);
2162+
builder.field(value3);
2163+
builder.finish()
2164+
}
2165+
2166+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2167+
/// `debug_tuple_fields_finish` is more general, but this is faster for 4 fields.
2168+
#[doc(hidden)]
2169+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2170+
pub fn debug_tuple_field4_finish<'b>(
2171+
&'b mut self,
2172+
name: &str,
2173+
value1: &dyn Debug,
2174+
value2: &dyn Debug,
2175+
value3: &dyn Debug,
2176+
value4: &dyn Debug,
2177+
) -> Result {
2178+
let mut builder = builders::debug_tuple_new(self, name);
2179+
builder.field(value1);
2180+
builder.field(value2);
2181+
builder.field(value3);
2182+
builder.field(value4);
2183+
builder.finish()
2184+
}
2185+
2186+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2187+
/// `debug_tuple_fields_finish` is more general, but this is faster for 5 fields.
2188+
#[doc(hidden)]
2189+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2190+
pub fn debug_tuple_field5_finish<'b>(
2191+
&'b mut self,
2192+
name: &str,
2193+
value1: &dyn Debug,
2194+
value2: &dyn Debug,
2195+
value3: &dyn Debug,
2196+
value4: &dyn Debug,
2197+
value5: &dyn Debug,
2198+
) -> Result {
2199+
let mut builder = builders::debug_tuple_new(self, name);
2200+
builder.field(value1);
2201+
builder.field(value2);
2202+
builder.field(value3);
2203+
builder.field(value4);
2204+
builder.field(value5);
2205+
builder.finish()
2206+
}
2207+
2208+
/// Used to shrink `derive(Debug)` code, for faster compilation and smaller binaries.
2209+
/// For the cases not covered by `debug_tuple_field[12345]_finish`.
2210+
#[doc(hidden)]
2211+
#[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
2212+
pub fn debug_tuple_fields_finish<'b>(
2213+
&'b mut self,
2214+
name: &str,
2215+
values: &[&dyn Debug],
2216+
) -> Result {
2217+
let mut builder = builders::debug_tuple_new(self, name);
2218+
for value in values {
2219+
builder.field(value);
2220+
}
2221+
builder.finish()
2222+
}
2223+
19982224
/// Creates a `DebugList` builder designed to assist with creation of
19992225
/// `fmt::Debug` implementations for list-like structures.
20002226
///

0 commit comments

Comments
 (0)