debug-fmt-detail option

Allows disabling `fmt::Debug` derive and debug formatting.

Author: kornelski

compiler/rustc_ast_lowering/src/format.rs

@@ -5,6 +5,7 @@ use rustc_ast::visit::Visitor;
 use rustc_ast::*;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir as hir;
+use rustc_session::config::DebugFmtDetail;
 use rustc_span::{
     sym,
     symbol::{kw, Ident},
@@ -205,7 +206,10 @@ fn make_argument<'hir>(
         hir::LangItem::FormatArgument,
         match ty {
             Format(Display) => sym::new_display,
-            Format(Debug) => sym::new_debug,
+            Format(Debug) => match ctx.tcx.sess.opts.unstable_opts.debug_fmt_detail {
+                DebugFmtDetail::Full | DebugFmtDetail::Shallow => sym::new_debug,
+                DebugFmtDetail::None => sym::new_debug_noop,
+            },
             Format(LowerExp) => sym::new_lower_exp,
             Format(UpperExp) => sym::new_upper_exp,
             Format(Octal) => sym::new_octal,

compiler/rustc_builtin_macros/src/deriving/debug.rs

@@ -4,6 +4,7 @@ use crate::deriving::path_std;
 
 use rustc_ast::{self as ast, EnumDef, MetaItem};
 use rustc_expand::base::{Annotatable, ExtCtxt};
+use rustc_session::config::DebugFmtDetail;
 use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
 use thin_vec::{thin_vec, ThinVec};
@@ -49,6 +50,11 @@ fn show_substructure(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) ->
     // We want to make sure we have the ctxt set so that we can use unstable methods
     let span = cx.with_def_site_ctxt(span);
 
+    let fmt_detail = cx.sess.opts.unstable_opts.debug_fmt_detail;
+    if fmt_detail == DebugFmtDetail::None {
+        return BlockOrExpr::new_expr(cx.expr_ok(span, cx.expr_tuple(span, ThinVec::new())));
+    }
+
     let (ident, vdata, fields) = match substr.fields {
         Struct(vdata, fields) => (substr.type_ident, *vdata, fields),
         EnumMatching(_, v, fields) => (v.ident, &v.data, fields),
@@ -61,6 +67,13 @@ fn show_substructure(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) ->
     let name = cx.expr_str(span, ident.name);
     let fmt = substr.nonselflike_args[0].clone();
 
+    // Fieldless enums have been special-cased earlier
+    if fmt_detail == DebugFmtDetail::Shallow {
+        let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]);
+        let expr = cx.expr_call_global(span, fn_path_write_str, thin_vec![fmt, name]);
+        return BlockOrExpr::new_expr(expr);
+    }
+
     // Struct and tuples are similar enough that we use the same code for both,
     // with some extra pieces for structs due to the field names.
     let (is_struct, args_per_field) = match vdata {

compiler/rustc_feature/src/builtin_attrs.rs

@@ -38,6 +38,7 @@ const GATED_CFGS: &[GatedCfg] = &[
     (sym::relocation_model, sym::cfg_relocation_model, cfg_fn!(cfg_relocation_model)),
     (sym::sanitizer_cfi_generalize_pointers, sym::cfg_sanitizer_cfi, cfg_fn!(cfg_sanitizer_cfi)),
     (sym::sanitizer_cfi_normalize_integers, sym::cfg_sanitizer_cfi, cfg_fn!(cfg_sanitizer_cfi)),
+    (sym::debug_fmt_detail, sym::debug_fmt_detail, cfg_fn!(debug_fmt_detail)),
 ];
 
 /// Find a gated cfg determined by the `pred`icate which is given the cfg's name.

compiler/rustc_feature/src/unstable.rs

@@ -432,6 +432,8 @@ declare_features! (
     (unstable, custom_inner_attributes, "1.30.0", Some(54726)),
     /// Allows custom test frameworks with `#![test_runner]` and `#[test_case]`.
     (unstable, custom_test_frameworks, "1.30.0", Some(50297)),
+    /// Disabling fmt::Debug
+    (unstable, debug_fmt_detail, "CURRENT_RUSTC_VERSION", Some(123940)),
     /// Allows declarative macros 2.0 (`macro`).
     (unstable, decl_macro, "1.17.0", Some(39412)),
     /// Allows default type parameters to influence type inference.

compiler/rustc_interface/src/tests.rs

@@ -4,12 +4,12 @@ use rustc_data_structures::profiling::TimePassesFormat;
 use rustc_errors::{emitter::HumanReadableErrorType, registry, ColorConfig};
 use rustc_session::config::{
     build_configuration, build_session_options, rustc_optgroups, BranchProtection, CFGuard, Cfg,
-    CollapseMacroDebuginfo, CoverageOptions, DebugInfo, DumpMonoStatsFormat, ErrorOutputType,
-    ExternEntry, ExternLocation, Externs, FunctionReturn, InliningThreshold, Input,
-    InstrumentCoverage, InstrumentXRay, LinkSelfContained, LinkerPluginLto, LocationDetail, LtoCli,
-    NextSolverConfig, OomStrategy, Options, OutFileName, OutputType, OutputTypes, PAuthKey, PacRet,
-    Passes, Polonius, ProcMacroExecutionStrategy, Strip, SwitchWithOptPath, SymbolManglingVersion,
-    WasiExecModel,
+    CollapseMacroDebuginfo, CoverageOptions, DebugFmtDetail, DebugInfo, DumpMonoStatsFormat,
+    ErrorOutputType, ExternEntry, ExternLocation, Externs, FunctionReturn, InliningThreshold,
+    Input, InstrumentCoverage, InstrumentXRay, LinkSelfContained, LinkerPluginLto, LocationDetail,
+    LtoCli, NextSolverConfig, OomStrategy, Options, OutFileName, OutputType, OutputTypes, PAuthKey,
+    PacRet, Passes, Polonius, ProcMacroExecutionStrategy, Strip, SwitchWithOptPath,
+    SymbolManglingVersion, WasiExecModel,
 };
 use rustc_session::lint::Level;
 use rustc_session::search_paths::SearchPath;
@@ -762,6 +762,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(coverage_options, CoverageOptions { branch: true });
     tracked!(crate_attr, vec!["abc".to_string()]);
     tracked!(cross_crate_inline_threshold, InliningThreshold::Always);
+    tracked!(debug_fmt_detail, DebugFmtDetail::Full);
     tracked!(debug_info_for_profiling, true);
     tracked!(debug_macros, true);
     tracked!(default_hidden_visibility, Some(true));

compiler/rustc_session/src/config.rs

@@ -360,6 +360,17 @@ impl LocationDetail {
     }
 }
 
+/// Values for the `-Z debug-fmt-detail` flag.
+#[derive(Copy, Clone, PartialEq, Hash, Debug)]
+pub enum DebugFmtDetail {
+    /// Derive fully-featured implementation
+    Full,
+    /// Print only type name, without fields
+    Shallow,
+    /// `#[derive(Debug)]` and `{:?}` are no-ops
+    None,
+}
+
 #[derive(Clone, PartialEq, Hash, Debug)]
 pub enum SwitchWithOptPath {
     Enabled(Option<PathBuf>),
@@ -2863,10 +2874,10 @@ pub enum WasiExecModel {
 pub(crate) mod dep_tracking {
     use super::{
         BranchProtection, CFGuard, CFProtection, CollapseMacroDebuginfo, CoverageOptions,
-        CrateType, DebugInfo, DebugInfoCompression, ErrorOutputType, FunctionReturn,
-        InliningThreshold, InstrumentCoverage, InstrumentXRay, LinkerPluginLto, LocationDetail,
-        LtoCli, NextSolverConfig, OomStrategy, OptLevel, OutFileName, OutputType, OutputTypes,
-        Polonius, RemapPathScopeComponents, ResolveDocLinks, SourceFileHashAlgorithm,
+        CrateType, DebugFmtDetail, DebugInfo, DebugInfoCompression, ErrorOutputType,
+        FunctionReturn, InliningThreshold, InstrumentCoverage, InstrumentXRay, LinkerPluginLto,
+        LocationDetail, LtoCli, NextSolverConfig, OomStrategy, OptLevel, OutFileName, OutputType,
+        OutputTypes, Polonius, RemapPathScopeComponents, ResolveDocLinks, SourceFileHashAlgorithm,
         SplitDwarfKind, SwitchWithOptPath, SymbolManglingVersion, WasiExecModel,
     };
     use crate::lint;
@@ -2968,6 +2979,7 @@ pub(crate) mod dep_tracking {
         OutputType,
         RealFileName,
         LocationDetail,
+        DebugFmtDetail,
         BranchProtection,
         OomStrategy,
         LanguageIdentifier,

compiler/rustc_session/src/config/cfg.rs

@@ -25,7 +25,7 @@ use rustc_target::abi::Align;
 use rustc_target::spec::{PanicStrategy, RelocModel, SanitizerSet};
 use rustc_target::spec::{Target, TargetTriple, TARGETS};
 
-use crate::config::CrateType;
+use crate::config::{CrateType, DebugFmtDetail};
 use crate::Session;
 
 use std::hash::Hash;
@@ -115,6 +115,18 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg {
         ins_none!(sym::debug_assertions);
     }
 
+    match sess.opts.unstable_opts.debug_fmt_detail {
+        DebugFmtDetail::Full => {
+            ins_str!(sym::debug_fmt_detail, "full");
+        }
+        DebugFmtDetail::Shallow => {
+            ins_str!(sym::debug_fmt_detail, "shallow");
+        }
+        DebugFmtDetail::None => {
+            ins_str!(sym::debug_fmt_detail, "none");
+        }
+    }
+
     if sess.overflow_checks() {
         ins_none!(sym::overflow_checks);
     }

compiler/rustc_session/src/options.rs

@@ -406,6 +406,7 @@ mod desc {
     pub const parse_linker_plugin_lto: &str =
         "either a boolean (`yes`, `no`, `on`, `off`, etc), or the path to the linker plugin";
     pub const parse_location_detail: &str = "either `none`, or a comma separated list of location details to track: `file`, `line`, or `column`";
+    pub const parse_debug_fmt_detail: &str = "either `full`, `shallow`, or `none`";
     pub const parse_switch_with_opt_path: &str =
         "an optional path to the profiling data output directory";
     pub const parse_merge_functions: &str = "one of: `disabled`, `trampolines`, or `aliases`";
@@ -585,6 +586,16 @@ mod parse {
         }
     }
 
+    pub(crate) fn parse_debug_fmt_detail(opt: &mut DebugFmtDetail, v: Option<&str>) -> bool {
+        *opt = match v {
+            Some("full") => DebugFmtDetail::Full,
+            Some("shallow") => DebugFmtDetail::Shallow,
+            Some("none") => DebugFmtDetail::None,
+            _ => return false,
+        };
+        true
+    }
+
     pub(crate) fn parse_location_detail(ld: &mut LocationDetail, v: Option<&str>) -> bool {
         if let Some(v) = v {
             ld.line = false;
@@ -1606,6 +1617,9 @@ options! {
         "inject the given attribute in the crate"),
     cross_crate_inline_threshold: InliningThreshold = (InliningThreshold::Sometimes(100), parse_inlining_threshold, [TRACKED],
         "threshold to allow cross crate inlining of functions"),
+    debug_fmt_detail: DebugFmtDetail = (DebugFmtDetail::Full, parse_debug_fmt_detail, [TRACKED],
+        "How detailed `#[derive(Debug)]` should be. `full` prints types recursively, \
+        `shallow` prints only type names, `none` prints nothing and disables `{:?}`. (default: `full`)"),
     debug_info_for_profiling: bool = (false, parse_bool, [TRACKED],
         "emit discriminators and other data necessary for AutoFDO"),
     debug_macros: bool = (false, parse_bool, [TRACKED],

compiler/rustc_span/src/symbol.rs

@@ -658,6 +658,7 @@ symbols! {
         debug_assert_macro,
         debug_assert_ne_macro,
         debug_assertions,
+        debug_fmt_detail,
         debug_struct,
         debug_struct_fields_finish,
         debug_tuple,
@@ -1227,6 +1228,7 @@ symbols! {
         new_binary,
         new_const,
         new_debug,
+        new_debug_noop,
         new_display,
         new_lower_exp,
         new_lower_hex,

library/core/src/fmt/rt.rs

@@ -117,6 +117,10 @@ impl<'a> Argument<'a> {
         Self::new(x, Debug::fmt)
     }
     #[inline(always)]
+    pub fn new_debug_noop<'b, T: Debug>(x: &'b T) -> Argument<'_> {
+        Self::new(x, |_, _| Ok(()))
+    }
+    #[inline(always)]
     pub fn new_octal<'b, T: Octal>(x: &'b T) -> Argument<'_> {
         Self::new(x, Octal::fmt)
     }

tests/ui/debug_fmt_detail/full.rs

@@ -0,0 +1,15 @@
+//@ compile-flags: -Zdebug-fmt-detail=full
+//@ run-pass
+#![feature(debug_fmt_detail)]
+#![allow(dead_code)]
+#![allow(unused)]
+
+#[derive(Debug)]
+struct Foo {
+    bar: u32,
+}
+
+fn main() {
+    let s = format!("Still works: {:?} '{:?}'", cfg!(debug_fmt_detail = "full"), Foo { bar: 1 });
+    assert_eq!("Still works: true 'Foo { bar: 1 }'", s);
+}

tests/ui/debug_fmt_detail/none.rs

@@ -0,0 +1,37 @@
+//@ compile-flags: -Zdebug-fmt-detail=none
+//@ run-pass
+#![feature(debug_fmt_detail)]
+#![allow(dead_code)]
+#![allow(unused)]
+
+#[derive(Debug)]
+struct Foo {
+    bar: u32,
+}
+
+#[derive(Debug)]
+enum Baz {
+    Quz,
+}
+
+#[cfg(debug_fmt_detail = "full")]
+compile_error!("nope");
+
+#[cfg(debug_fmt_detail = "none")]
+struct Custom;
+
+impl std::fmt::Debug for Custom {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("custom_fmt")
+    }
+}
+
+fn main() {
+    let c = Custom;
+    let s = format!("Debug is '{:?}', '{:#?}', and '{c:?}'", Foo { bar: 1 }, Baz::Quz);
+    assert_eq!("Debug is '', '', and ''", s);
+
+    let f = 3.0;
+    let s = format_args!("{:?}x{:#?}y{f:?}", 1234, "can't debug this").to_string();
+    assert_eq!("xy", s);
+}

tests/ui/debug_fmt_detail/shallow.rs

@@ -0,0 +1,33 @@
+//@ compile-flags: -Zdebug-fmt-detail=shallow
+//@ run-pass
+#![feature(debug_fmt_detail)]
+#![allow(dead_code)]
+#![allow(unused)]
+
+#[derive(Debug)]
+struct Foo {
+    bar: u32,
+    bomb: Bomb,
+}
+
+#[derive(Debug)]
+enum Baz {
+    Quz,
+}
+
+struct Bomb;
+
+impl std::fmt::Debug for Bomb {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        panic!()
+    }
+}
+
+fn main() {
+    let s = format!("Debug is '{:?}' and '{:#?}'", Foo { bar: 1, bomb: Bomb }, Baz::Quz);
+    assert_eq!("Debug is 'Foo' and 'Quz'", s);
+
+    let f = 3.0;
+    let s = format_args!("{:?}{:#?}{f:?}", 1234, cfg!(debug_fmt_detail = "shallow")).to_string();
+    assert_eq!("1234true3.0", s);
+}