Use closure to allow passing custom tracing layers

The previous method, where a layer would be passed directly,
required to pass a "no-op" layer when no custom layer was needed.
This should have in theory worked, however having a no-op layer
seems to change the way the tracing lib applies filters internally,
leading to some debug!() being printed despite them being out of
the minimum level for the filters. Note however that this behavior
was very inconsistent, and e.g. some debug!() would get printed
and some others wouldn't, for no apparent reason.

Author: Stypox

compiler/rustc_driver_impl/src/lib.rs

@@ -1507,13 +1507,15 @@ pub fn init_logger(early_dcx: &EarlyDiagCtxt, cfg: rustc_log::LoggerConfig) {
     }
 }
 
-pub fn init_logger_with_additional_layer(
+pub fn init_logger_with_additional_layer<F, T>(
     early_dcx: &EarlyDiagCtxt,
     cfg: rustc_log::LoggerConfig,
-    additional_tracing_layer: impl rustc_log::Layer<rustc_log::Registry> + Send + Sync,
-) {
-    if let Err(error) = rustc_log::init_logger_with_additional_layer(cfg, additional_tracing_layer)
-    {
+    build_subscriber: F,
+) where
+    F: FnOnce() -> T,
+    T: rustc_log::BuildSubscriberRet,
+{
+    if let Err(error) = rustc_log::init_logger_with_additional_layer(cfg, build_subscriber) {
         early_dcx.early_fatal(error.to_string());
     }
 }

compiler/rustc_log/src/lib.rs

@@ -42,7 +42,7 @@ use tracing_core::{Event, Subscriber};
 use tracing_subscriber::filter::{Directive, EnvFilter, LevelFilter};
 use tracing_subscriber::fmt::FmtContext;
 use tracing_subscriber::fmt::format::{self, FormatEvent, FormatFields};
-use tracing_subscriber::layer::{Identity, SubscriberExt};
+use tracing_subscriber::layer::SubscriberExt;
 // Re-export tracing_subscriber items so rustc_driver_impl doesn't need to depend on it.
 pub use tracing_subscriber::{Layer, Registry};
 
@@ -74,15 +74,30 @@ impl LoggerConfig {
 
 /// Initialize the logger with the given values for the filter, coloring, and other options env variables.
 pub fn init_logger(cfg: LoggerConfig) -> Result<(), Error> {
-    init_logger_with_additional_layer(cfg, Identity::new())
+    init_logger_with_additional_layer(cfg, || Registry::default())
+}
+
+pub trait BuildSubscriberRet:
+    tracing::Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span> + Send + Sync
+{
+}
+
+impl<
+    T: tracing::Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span> + Send + Sync,
+> BuildSubscriberRet for T
+{
 }
 
 /// Initialize the logger with the given values for the filter, coloring, and other options env variables.
 /// Additionally add a custom layer to collect logging and tracing events.
-pub fn init_logger_with_additional_layer(
+pub fn init_logger_with_additional_layer<F, T>(
     cfg: LoggerConfig,
-    additional_tracing_layer: impl Layer<Registry> + Send + Sync,
-) -> Result<(), Error> {
+    build_subscriber: F,
+) -> Result<(), Error>
+where
+    F: FnOnce() -> T,
+    T: BuildSubscriberRet,
+{
     let filter = match cfg.filter {
         Ok(env) => EnvFilter::new(env),
         _ => EnvFilter::default().add_directive(Directive::from(LevelFilter::WARN)),
@@ -115,7 +130,7 @@ pub fn init_logger_with_additional_layer(
     };
 
     let mut layer = tracing_tree::HierarchicalLayer::default()
-        .with_writer(io::stderr as fn() -> io::Stderr)
+        .with_writer(io::stderr)
         .with_ansi(color_logs)
         .with_targets(true)
         .with_verbose_exit(verbose_entry_exit)
@@ -135,8 +150,7 @@ pub fn init_logger_with_additional_layer(
         Err(_) => {} // no wraptree
     }
 
-    let subscriber =
-        Registry::default().with(additional_tracing_layer).with(layer.with_filter(filter));
+    let subscriber = build_subscriber().with(layer.with_filter(filter));
     match cfg.backtrace {
         Ok(backtrace_target) => {
             let fmt_layer = tracing_subscriber::fmt::layer()