Auto merge of #143548 - Diggsey:db-limit-extern-crate-usage, r=oli-obk

Restrict sysroot crate imports to those defined in this repo.

It's common to import dependencies from the sysroot via `extern crate` rather than use an explicit cargo dependency, when it's necessary to use the same dependency version as used by rustc itself. However, this is dangerous for crates.io crates, since rustc may not pull in the dependency on some targets, or may pull in multiple versions. In both cases, the `extern crate` fails to resolve.

To address this, re-export all such dependencies from the appropriate `rustc_*` crates, and use this alias from crates which would otherwise need to use `extern crate`.

See rust-lang/rust#143492 for an example of the kind of issue that can occur.

Author: bors

src/bin/log/setup.rs

@@ -2,6 +2,7 @@ use std::env::{self, VarError};
 use std::str::FromStr;
 use std::sync::{Mutex, OnceLock};
 
+use rustc_log::tracing;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::{CtfeBacktrace, EarlyDiagCtxt};
 
@@ -72,8 +73,8 @@ fn init_logger_once(early_dcx: &EarlyDiagCtxt) {
                     early_dcx,
                     rustc_logger_config(),
                     || {
-                        tracing_subscriber::layer::SubscriberExt::with(
-                            tracing_subscriber::Registry::default(),
+                        rustc_log::tracing_subscriber::layer::SubscriberExt::with(
+                            rustc_log::tracing_subscriber::Registry::default(),
                             chrome_layer,
                         )
                     },

src/bin/log/tracing_chrome.rs

@@ -24,12 +24,9 @@
 #![allow(warnings)]
 #![cfg(feature = "tracing")]
 
-// This is here and not in src/lib.rs since it is a direct dependency of tracing_chrome.rs and
-// should not be included if the "tracing" feature is disabled.
-extern crate tracing_core;
-
-use tracing_core::{field::Field, span, Event, Subscriber};
-use tracing_subscriber::{
+use rustc_log::tracing_core::{field::Field, span, Event, Subscriber};
+use rustc_log::tracing_subscriber::{
+    self,
     layer::Context,
     registry::{LookupSpan, SpanRef},
     Layer,
@@ -526,16 +523,16 @@ where
                 }
             },
             TraceStyle::Async => Some(
-                span.scope()
-                    .from_root()
-                    .take(1)
-                    .next()
-                    .unwrap_or(span)
-                    .id()
-                    .into_u64()
+        span.scope()
+            .from_root()
+            .take(1)
+            .next()
+            .unwrap_or(span)
+            .id()
+            .into_u64()
                     .cast_signed() // the comment above explains the cast
             ),
-        }
+    }
     }
 
     fn enter_span(&self, span: SpanRef<S>, ts: f64, tid: usize, out: &Sender<Message>) {
@@ -570,11 +567,11 @@ where
                 Some(thread_data) => (thread_data, false),
                 None => {
                     let tid = self.max_tid.fetch_add(1, Ordering::SeqCst);
-                    let out = self.out.lock().unwrap().clone();
+                let out = self.out.lock().unwrap().clone();
                     let start = TracingChromeInstant::setup_for_thread_and_start(tid);
                     *thread_data = Some(ThreadData { tid, out, start });
                     (thread_data.as_mut().unwrap(), true)
-                }
+            }
             };
 
             start.with_elapsed_micros_subtracting_tracing(|ts| {
@@ -586,7 +583,7 @@ where
                     let _ignored = out.send(Message::NewThread(*tid, name));
                 }
                 f(ts, *tid, out);
-            });
+        });
         });
     }
 }
@@ -608,15 +605,15 @@ where
     fn on_record(&self, id: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
         if self.include_args {
             self.with_elapsed_micros_subtracting_tracing(|_, _, _| {
-                let span = ctx.span(id).unwrap();
-                let mut exts = span.extensions_mut();
+            let span = ctx.span(id).unwrap();
+            let mut exts = span.extensions_mut();
 
-                let args = exts.get_mut::<ArgsWrapper>();
+            let args = exts.get_mut::<ArgsWrapper>();
 
-                if let Some(args) = args {
-                    let args = Arc::make_mut(&mut args.args);
-                    values.record(&mut JsonVisitor { object: args });
-                }
+            if let Some(args) = args {
+                let args = Arc::make_mut(&mut args.args);
+                values.record(&mut JsonVisitor { object: args });
+            }
             });
         }
     }
@@ -639,16 +636,16 @@ where
 
     fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
         self.with_elapsed_micros_subtracting_tracing(|ts, tid, out| {
-            if self.include_args {
-                let mut args = Object::new();
-                attrs.record(&mut JsonVisitor { object: &mut args });
-                ctx.span(id).unwrap().extensions_mut().insert(ArgsWrapper {
-                    args: Arc::new(args),
-                });
-            }
-            if let TraceStyle::Threaded = self.trace_style {
-                return;
-            }
+        if self.include_args {
+            let mut args = Object::new();
+            attrs.record(&mut JsonVisitor { object: &mut args });
+            ctx.span(id).unwrap().extensions_mut().insert(ArgsWrapper {
+                args: Arc::new(args),
+            });
+        }
+        if let TraceStyle::Threaded = self.trace_style {
+            return;
+        }
 
             self.enter_span(ctx.span(id).expect("Span not found."), ts, tid, out);
         });

src/bin/miri.rs

@@ -8,11 +8,6 @@
     rustc::untranslatable_diagnostic
 )]
 
-// Some "regular" crates we want to share with rustc
-extern crate tracing;
-#[cfg(feature = "tracing")]
-extern crate tracing_subscriber;
-
 // The rustc crates we need
 extern crate rustc_abi;
 extern crate rustc_data_structures;
@@ -48,6 +43,7 @@ use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{self as hir, Node};
 use rustc_hir_analysis::check::check_function_signature;
 use rustc_interface::interface::Config;
+use rustc_log::tracing::debug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::exported_symbols::{
     ExportedSymbol, SymbolExportInfo, SymbolExportKind, SymbolExportLevel,
@@ -60,7 +56,6 @@ use rustc_session::EarlyDiagCtxt;
 use rustc_session::config::{CrateType, ErrorOutputType, OptLevel};
 use rustc_session::search_paths::PathKind;
 use rustc_span::def_id::DefId;
-use tracing::debug;
 
 use crate::log::setup::{deinit_loggers, init_early_loggers, init_late_loggers};
 

src/borrow_tracker/stacked_borrows/stack.rs

@@ -2,7 +2,7 @@
 use std::ops::Range;
 
 use rustc_data_structures::fx::FxHashSet;
-use tracing::trace;
+use rustc_log::tracing::trace;
 
 use crate::borrow_tracker::stacked_borrows::{Item, Permission};
 use crate::borrow_tracker::{AccessKind, BorTag};

src/concurrency/data_race.rs

@@ -48,6 +48,7 @@ use rustc_abi::{Align, HasDataLayout, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_index::{Idx, IndexVec};
+use rustc_log::tracing;
 use rustc_middle::mir;
 use rustc_middle::ty::Ty;
 use rustc_span::Span;

src/concurrency/thread.rs

@@ -5,10 +5,10 @@ use std::sync::atomic::Ordering::Relaxed;
 use std::task::Poll;
 use std::time::{Duration, SystemTime};
 
-use either::Either;
 use rand::seq::IteratorRandom;
 use rustc_abi::ExternAbi;
 use rustc_const_eval::CTRL_C_RECEIVED;
+use rustc_data_structures::either::Either;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
 use rustc_index::{Idx, IndexVec};

src/intrinsics/simd.rs

@@ -38,47 +38,47 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 for i in 0..dest_len {
                     let op = this.read_immediate(&this.project_index(&op, i)?)?;
                     let dest = this.project_index(&dest, i)?;
-                    let ty::Float(float_ty) = op.layout.ty.kind() else {
-                        span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
-                    };
-                    // Using host floats except for sqrt (but it's fine, these operations do not
-                    // have guaranteed precision).
+                            let ty::Float(float_ty) = op.layout.ty.kind() else {
+                                span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
+                            };
+                            // Using host floats except for sqrt (but it's fine, these operations do not
+                            // have guaranteed precision).
                     let val = match float_ty {
-                        FloatTy::F16 => unimplemented!("f16_f128"),
-                        FloatTy::F32 => {
-                            let f = op.to_scalar().to_f32()?;
+                                FloatTy::F16 => unimplemented!("f16_f128"),
+                                FloatTy::F32 => {
+                                    let f = op.to_scalar().to_f32()?;
                             let res = match intrinsic_name {
-                                "fsqrt" => math::sqrt(f),
-                                "fsin" => f.to_host().sin().to_soft(),
-                                "fcos" => f.to_host().cos().to_soft(),
-                                "fexp" => f.to_host().exp().to_soft(),
-                                "fexp2" => f.to_host().exp2().to_soft(),
-                                "flog" => f.to_host().ln().to_soft(),
-                                "flog2" => f.to_host().log2().to_soft(),
-                                "flog10" => f.to_host().log10().to_soft(),
-                                _ => bug!(),
-                            };
-                            let res = this.adjust_nan(res, &[f]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F64 => {
-                            let f = op.to_scalar().to_f64()?;
+                                        "fsqrt" => math::sqrt(f),
+                                        "fsin" => f.to_host().sin().to_soft(),
+                                        "fcos" => f.to_host().cos().to_soft(),
+                                        "fexp" => f.to_host().exp().to_soft(),
+                                        "fexp2" => f.to_host().exp2().to_soft(),
+                                        "flog" => f.to_host().ln().to_soft(),
+                                        "flog2" => f.to_host().log2().to_soft(),
+                                        "flog10" => f.to_host().log10().to_soft(),
+                                        _ => bug!(),
+                                    };
+                                    let res = this.adjust_nan(res, &[f]);
+                                    Scalar::from(res)
+                                }
+                                FloatTy::F64 => {
+                                    let f = op.to_scalar().to_f64()?;
                             let res = match intrinsic_name {
-                                "fsqrt" => math::sqrt(f),
-                                "fsin" => f.to_host().sin().to_soft(),
-                                "fcos" => f.to_host().cos().to_soft(),
-                                "fexp" => f.to_host().exp().to_soft(),
-                                "fexp2" => f.to_host().exp2().to_soft(),
-                                "flog" => f.to_host().ln().to_soft(),
-                                "flog2" => f.to_host().log2().to_soft(),
-                                "flog10" => f.to_host().log10().to_soft(),
-                                _ => bug!(),
+                                        "fsqrt" => math::sqrt(f),
+                                        "fsin" => f.to_host().sin().to_soft(),
+                                        "fcos" => f.to_host().cos().to_soft(),
+                                        "fexp" => f.to_host().exp().to_soft(),
+                                        "fexp2" => f.to_host().exp2().to_soft(),
+                                        "flog" => f.to_host().ln().to_soft(),
+                                        "flog2" => f.to_host().log2().to_soft(),
+                                        "flog10" => f.to_host().log10().to_soft(),
+                                        _ => bug!(),
+                                    };
+                                    let res = this.adjust_nan(res, &[f]);
+                                    Scalar::from(res)
+                                }
+                                FloatTy::F128 => unimplemented!("f16_f128"),
                             };
-                            let res = this.adjust_nan(res, &[f]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F128 => unimplemented!("f16_f128"),
-                    };
 
                     this.write_scalar(val, &dest)?;
                 }

src/lib.rs

@@ -49,10 +49,6 @@
 // Needed for rustdoc from bootstrap (with `-Znormalize-docs`).
 #![recursion_limit = "256"]
 
-// Some "regular" crates we want to share with rustc
-extern crate either;
-extern crate tracing;
-
 // The rustc crates we need
 extern crate rustc_abi;
 extern crate rustc_apfloat;
@@ -63,6 +59,7 @@ extern crate rustc_errors;
 extern crate rustc_hash;
 extern crate rustc_hir;
 extern crate rustc_index;
+extern crate rustc_log;
 extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
@@ -96,8 +93,8 @@ pub use rustc_const_eval::interpret::*;
 // Resolve ambiguity.
 #[doc(no_inline)]
 pub use rustc_const_eval::interpret::{self, AllocMap, Provenance as _};
+use rustc_log::tracing::{self, info, trace};
 use rustc_middle::{bug, span_bug};
-use tracing::{info, trace};
 
 #[cfg(all(unix, feature = "native-lib"))]
 pub mod native_lib {

src/machine.rs

@@ -16,6 +16,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 #[allow(unused)]
 use rustc_data_structures::static_assert_size;
 use rustc_hir::attrs::InlineAttr;
+use rustc_log::tracing;
 use rustc_middle::middle::codegen_fn_attrs::TargetFeatureKind;
 use rustc_middle::mir;
 use rustc_middle::query::TyCtxtAt;

src/provenance_gc.rs

@@ -1,4 +1,4 @@
-use either::Either;
+use rustc_data_structures::either::Either;
 use rustc_data_structures::fx::FxHashSet;
 
 use crate::*;