Remove more Session methods that duplicate DiagCtxt methods.

nnethercote · nnethercote · commit 8a9db2545919 · 2023-12-24T08:17:47.000+11:00
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
@@ -529,7 +529,7 @@ fn make_format_args(
 
     // Only check for unused named argument names if there are no other errors to avoid causing
     // too much noise in output errors, such as when a named argument is entirely unused.
-    if invalid_refs.is_empty() && ecx.sess.err_count() == 0 {
+    if invalid_refs.is_empty() && ecx.dcx().err_count() == 0 {
         for &(index, span, used_as) in &numeric_refences_to_named_arg {
             let (position_sp_to_replace, position_sp_for_msg) = match used_as {
                 Placeholder(pspan) => (span, pspan),
diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -108,7 +108,7 @@ impl OngoingCodegen {
 
         self.concurrency_limiter.finished();
 
-        sess.abort_if_errors();
+        sess.dcx().abort_if_errors();
 
         (
             CodegenResults {
diff --git a/compiler/rustc_codegen_cranelift/src/driver/jit.rs b/compiler/rustc_codegen_cranelift/src/driver/jit.rs
@@ -151,7 +151,7 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, backend_config: BackendConfig) -> ! {
         tcx.dcx().fatal("Inline asm is not supported in JIT mode");
     }
 
-    tcx.sess.abort_if_errors();
+    tcx.dcx().abort_if_errors();
 
     jit_module.finalize_definitions().unwrap();
     unsafe { cx.unwind_context.register_jit(&jit_module) };
@@ -338,7 +338,7 @@ fn dep_symbol_lookup_fn(
             .collect::<Box<[_]>>(),
     );
 
-    sess.abort_if_errors();
+    sess.dcx().abort_if_errors();
 
     Box::new(move |sym_name| {
         for dylib in &*imported_dylibs {
diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -204,7 +204,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
         metadata: EncodedMetadata,
         need_metadata_module: bool,
     ) -> Box<dyn Any> {
-        tcx.sess.abort_if_errors();
+        tcx.dcx().abort_if_errors();
         let config = self.config.borrow().clone().unwrap();
         match config.codegen_mode {
             CodegenMode::Aot => driver::aot::run_aot(tcx, config, metadata, need_metadata_module),
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -716,7 +716,7 @@ fn link_dwarf_object<'a>(
         Ok(()) => {}
         Err(e) => {
             sess.dcx().emit_err(errors::ThorinErrorWrapper(e));
-            sess.abort_if_errors();
+            sess.dcx().abort_if_errors();
         }
     }
 }
@@ -765,7 +765,7 @@ fn link_natively<'a>(
     }
 
     // May have not found libraries in the right formats.
-    sess.abort_if_errors();
+    sess.dcx().abort_if_errors();
 
     // Invoke the system linker
     info!("{:?}", &cmd);
@@ -970,7 +970,7 @@ fn link_natively<'a>(
                     }
                 }
 
-                sess.abort_if_errors();
+                sess.dcx().abort_if_errors();
             }
             info!("linker stderr:\n{}", escape_string(&prog.stderr));
             info!("linker stdout:\n{}", escape_string(&prog.stdout));
@@ -993,7 +993,7 @@ fn link_natively<'a>(
                 sess.dcx().emit_note(errors::CheckInstalledVisualStudio);
                 sess.dcx().emit_note(errors::InsufficientVSCodeProduct);
             }
-            sess.abort_if_errors();
+            sess.dcx().abort_if_errors();
         }
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -1883,7 +1883,7 @@ impl SharedEmitterMain {
                     err.emit();
                 }
                 Ok(SharedEmitterMessage::AbortIfErrors) => {
-                    sess.abort_if_errors();
+                    sess.dcx().abort_if_errors();
                 }
                 Ok(SharedEmitterMessage::Fatal(msg)) => {
                     sess.dcx().fatal(msg);
@@ -1939,15 +1939,15 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
         let compiled_modules = sess.time("join_worker_thread", || match self.coordinator.join() {
             Ok(Ok(compiled_modules)) => compiled_modules,
             Ok(Err(())) => {
-                sess.abort_if_errors();
+                sess.dcx().abort_if_errors();
                 panic!("expected abort due to worker thread errors")
             }
             Err(_) => {
                 bug!("panic during codegen/LLVM phase");
             }
         });
 
-        sess.abort_if_errors();
+        sess.dcx().abort_if_errors();
 
         let work_products =
             copy_all_cgu_workproducts_to_incr_comp_cache_dir(sess, &compiled_modules);
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
@@ -448,8 +448,9 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         let Some(llfn) = cx.declare_c_main(llfty) else {
             // FIXME: We should be smart and show a better diagnostic here.
             let span = cx.tcx().def_span(rust_main_def_id);
-            cx.sess().dcx().emit_err(errors::MultipleMainFunctions { span });
-            cx.sess().abort_if_errors();
+            let dcx = cx.tcx().dcx();
+            dcx.emit_err(errors::MultipleMainFunctions { span });
+            dcx.abort_if_errors();
             bug!();
         };
 
@@ -752,7 +753,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
                 // This will unwind if there are errors, which triggers our `AbortCodegenOnDrop`
                 // guard. Unfortunately, just skipping the `submit_codegened_module_to_llvm` makes
                 // compilation hang on post-monomorphization errors.
-                tcx.sess.abort_if_errors();
+                tcx.dcx().abort_if_errors();
 
                 submit_codegened_module_to_llvm(
                     &backend,
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -279,7 +279,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                 self.tcx.dcx().emit_diagnostic(error);
             }
         } else {
-            assert!(self.tcx.sess.has_errors().is_some());
+            assert!(self.tcx.dcx().has_errors().is_some());
         }
     }
 
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
@@ -150,7 +150,7 @@ pub const DEFAULT_BUG_REPORT_URL: &str = "https://github.com/rust-lang/rust/issu
 pub fn abort_on_err<T>(result: Result<T, ErrorGuaranteed>, sess: &Session) -> T {
     match result {
         Err(..) => {
-            sess.abort_if_errors();
+            sess.dcx().abort_if_errors();
             panic!("error reported but abort_if_errors didn't abort???");
         }
         Ok(x) => x,
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1284,7 +1284,7 @@ pub(super) fn check_type_params_are_used<'tcx>(
     if ty.references_error() {
         // If there is already another error, do not emit
         // an error for not using a type parameter.
-        assert!(tcx.sess.has_errors().is_some());
+        assert!(tcx.dcx().has_errors().is_some());
         return;
     }
 
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -115,7 +115,7 @@ where
     let errors = wfcx.select_all_or_error();
     if !errors.is_empty() {
         let err = infcx.err_ctxt().report_fulfillment_errors(errors);
-        if tcx.sess.err_count() > 0 {
+        if tcx.dcx().err_count() > 0 {
             return Err(err);
         } else {
             // HACK(oli-obk): tests/ui/specialization/min_specialization/specialize_on_type_error.rs
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
@@ -234,7 +234,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
 
     tcx.ensure().check_unused_traits(());
 
-    if let Some(reported) = tcx.sess.has_errors() { Err(reported) } else { Ok(()) }
+    if let Some(reported) = tcx.dcx().has_errors() { Err(reported) } else { Ok(()) }
 }
 
 /// A quasi-deprecated helper used in rustdoc and clippy to get
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
@@ -690,7 +690,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // else an error would have been flagged by the
                 // `loops` pass for using break with an expression
                 // where you are not supposed to.
-                assert!(expr_opt.is_none() || self.tcx.sess.has_errors().is_some());
+                assert!(expr_opt.is_none() || self.dcx().has_errors().is_some());
             }
 
             // If we encountered a `break`, then (no surprise) it may be possible to break from the
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -576,7 +576,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
                 // struct; however, when EUV is run during typeck, it
                 // may not. This will generate an error earlier in typeck,
                 // so we can just ignore it.
-                if self.tcx().sess.has_errors().is_none() {
+                if self.tcx().dcx().has_errors().is_none() {
                     span_bug!(with_expr.span, "with expression doesn't evaluate to a struct");
                 }
             }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -119,7 +119,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         FnCtxt {
             body_id,
             param_env,
-            err_count_on_creation: inh.tcx.sess.err_count(),
+            err_count_on_creation: inh.tcx.dcx().err_count(),
             ret_coercion: None,
             ret_coercion_span: Cell::new(None),
             resume_yield_tys: None,
@@ -188,7 +188,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     pub fn errors_reported_since_creation(&self) -> bool {
-        self.tcx.sess.err_count() > self.err_count_on_creation
+        self.dcx().err_count() > self.err_count_on_creation
     }
 
     pub fn next_root_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -753,7 +753,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
     }
 
     fn report_error(&self, p: impl Into<ty::GenericArg<'tcx>>) -> ErrorGuaranteed {
-        match self.fcx.tcx.sess.has_errors() {
+        match self.fcx.dcx().has_errors() {
             Some(e) => e,
             None => self
                 .fcx
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
@@ -312,7 +312,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
 
     let incr_comp_session_dir: PathBuf = sess.incr_comp_session_dir().clone();
 
-    if let Some(_) = sess.has_errors_or_span_delayed_bugs() {
+    if let Some(_) = sess.dcx().has_errors_or_span_delayed_bugs() {
         // If there have been any errors during compilation, we don't want to
         // publish this session directory. Rather, we'll just delete it.
 
diff --git a/compiler/rustc_incremental/src/persist/save.rs b/compiler/rustc_incremental/src/persist/save.rs
@@ -32,7 +32,7 @@ pub fn save_dep_graph(tcx: TyCtxt<'_>) {
             return;
         }
         // This is going to be deleted in finalize_session_directory, so let's not create it
-        if let Some(_) = sess.has_errors_or_span_delayed_bugs() {
+        if let Some(_) = sess.dcx().has_errors_or_span_delayed_bugs() {
             return;
         }
 
@@ -87,7 +87,7 @@ pub fn save_work_product_index(
         return;
     }
     // This is going to be deleted in finalize_session_directory, so let's not create it
-    if let Some(_) = sess.has_errors_or_span_delayed_bugs() {
+    if let Some(_) = sess.dcx().has_errors_or_span_delayed_bugs() {
         return;
     }
 
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -133,7 +133,7 @@ pub struct TypeErrCtxt<'a, 'tcx> {
 
 impl Drop for TypeErrCtxt<'_, '_> {
     fn drop(&mut self) {
-        if let Some(_) = self.infcx.tcx.sess.has_errors_or_span_delayed_bugs() {
+        if let Some(_) = self.dcx().has_errors_or_span_delayed_bugs() {
             // ok, emitted an error.
         } else {
             self.infcx
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -704,7 +704,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
             reported_trait_errors: Default::default(),
             reported_closure_mismatch: Default::default(),
             tainted_by_errors: Cell::new(None),
-            err_count_on_creation: tcx.sess.err_count(),
+            err_count_on_creation: tcx.dcx().err_count(),
             universe: Cell::new(ty::UniverseIndex::ROOT),
             intercrate,
             next_trait_solver,
@@ -1262,7 +1262,7 @@ impl<'tcx> InferCtxt<'tcx> {
         debug!(
             "is_tainted_by_errors(err_count={}, err_count_on_creation={}, \
              tainted_by_errors={})",
-            self.tcx.sess.err_count(),
+            self.dcx().err_count(),
             self.err_count_on_creation,
             self.tainted_by_errors.get().is_some()
         );
@@ -1271,9 +1271,9 @@ impl<'tcx> InferCtxt<'tcx> {
             return Some(e);
         }
 
-        if self.tcx.sess.err_count() > self.err_count_on_creation {
+        if self.dcx().err_count() > self.err_count_on_creation {
             // errors reported since this infcx was made
-            let e = self.tcx.sess.has_errors().unwrap();
+            let e = self.dcx().has_errors().unwrap();
             self.set_tainted_by_errors(e);
             return Some(e);
         }
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
@@ -216,7 +216,7 @@ fn configure_and_expand(
         // If we hit a recursion limit, exit early to avoid later passes getting overwhelmed
         // with a large AST
         if ecx.reduced_recursion_limit.is_some() {
-            sess.abort_if_errors();
+            sess.dcx().abort_if_errors();
             unreachable!();
         }
 
@@ -776,7 +776,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
     // lot of annoying errors in the ui tests (basically,
     // lint warnings and so on -- kindck used to do this abort, but
     // kindck is gone now). -nmatsakis
-    if let Some(reported) = sess.has_errors() {
+    if let Some(reported) = sess.dcx().has_errors() {
         return Err(reported);
     }
 
@@ -937,8 +937,9 @@ pub fn start_codegen<'tcx>(
 
     if tcx.sess.opts.output_types.contains_key(&OutputType::Mir) {
         if let Err(error) = rustc_mir_transform::dump_mir::emit_mir(tcx) {
-            tcx.dcx().emit_err(errors::CantEmitMIR { error });
-            tcx.sess.abort_if_errors();
+            let dcx = tcx.dcx();
+            dcx.emit_err(errors::CantEmitMIR { error });
+            dcx.abort_if_errors();
         }
     }
 
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
@@ -925,7 +925,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // don't perform this validation if the session has errors, as one of
         // those errors may indicate a circular dependency which could cause
         // this to stack overflow.
-        if self.sess.has_errors().is_some() {
+        if self.dcx().has_errors().is_some() {
             return;
         }
 
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
@@ -55,7 +55,7 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {
     }
     fn error_reported(&self) -> Result<(), ErrorGuaranteed> {
         if self.references_error() {
-            if let Some(reported) = ty::tls::with(|tcx| tcx.sess.is_compilation_going_to_fail()) {
+            if let Some(reported) = ty::tls::with(|tcx| tcx.dcx().is_compilation_going_to_fail()) {
                 Err(reported)
             } else {
                 bug!("expect tcx.sess.is_compilation_going_to_fail return `Some`");
diff --git a/compiler/rustc_middle/src/values.rs b/compiler/rustc_middle/src/values.rs
@@ -51,7 +51,7 @@ impl<'tcx> Value<TyCtxt<'tcx>> for ty::Binder<'_, ty::FnSig<'_>> {
         {
             sig.decl.inputs.len() + sig.decl.implicit_self.has_implicit_self() as usize
         } else {
-            tcx.sess.abort_if_errors();
+            tcx.dcx().abort_if_errors();
             unreachable!()
         };
 
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -1110,7 +1110,7 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Co
 
     let (items, usage_map) = collector::collect_crate_mono_items(tcx, collection_mode);
 
-    tcx.sess.abort_if_errors();
+    tcx.dcx().abort_if_errors();
 
     let (codegen_units, _) = tcx.sess.time("partition_and_assert_distinct_symbols", || {
         sync::join(
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -2579,7 +2579,7 @@ fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
         check_invalid_crate_level_attr(tcx, tcx.hir().krate_attrs());
     }
     if check_attr_visitor.abort.get() {
-        tcx.sess.abort_if_errors()
+        tcx.dcx().abort_if_errors()
     }
 }
 
diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -818,7 +818,7 @@ impl<D: Deps> DepGraphData<D> {
             None => {}
         }
 
-        if let None = qcx.dep_context().sess().has_errors_or_span_delayed_bugs() {
+        if let None = qcx.dep_context().sess().dcx().has_errors_or_span_delayed_bugs() {
             panic!("try_mark_previous_green() - Forcing the DepNode should have set its color")
         }
 
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -126,7 +126,7 @@ where
         }
         Fatal => {
             error.emit();
-            qcx.dep_context().sess().abort_if_errors();
+            qcx.dep_context().sess().dcx().abort_if_errors();
             unreachable!()
         }
         DelayBug => {
diff --git a/compiler/rustc_query_system/src/values.rs b/compiler/rustc_query_system/src/values.rs
@@ -9,7 +9,7 @@ pub trait Value<Tcx: DepContext>: Sized {
 
 impl<Tcx: DepContext, T> Value<Tcx> for T {
     default fn from_cycle_error(tcx: Tcx, cycle: &[QueryInfo], _guar: ErrorGuaranteed) -> T {
-        tcx.sess().abort_if_errors();
+        tcx.sess().dcx().abort_if_errors();
         // Ideally we would use `bug!` here. But bug! is only defined in rustc_middle, and it's
         // non-trivial to define it earlier.
         panic!(
diff --git a/compiler/rustc_session/src/output.rs b/compiler/rustc_session/src/output.rs
@@ -115,7 +115,7 @@ pub fn validate_crate_name(sess: &Session, s: Symbol, sp: Option<Span>) {
     }
 
     if err_count > 0 {
-        sess.abort_if_errors();
+        sess.dcx().abort_if_errors();
     }
 }
 
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
diff --git a/tests/run-make-fulldeps/obtain-borrowck/driver.rs b/tests/run-make-fulldeps/obtain-borrowck/driver.rs

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ impl OngoingCodegen {`
`108`	`108`
`109`	`109`	`self.concurrency_limiter.finished();`
`110`	`110`
`111`		`- sess.abort_if_errors();`
	`111`	`+ sess.dcx().abort_if_errors();`
`112`	`112`
`113`	`113`	`(`
`114`	`114`	`CodegenResults {`
Original file line number	Diff line number	Diff line change
`@@ -716,7 +716,7 @@ fn link_dwarf_object<'a>(`
`716`	`716`	`Ok(()) => {}`
`717`	`717`	`Err(e) => {`
`718`	`718`	`sess.dcx().emit_err(errors::ThorinErrorWrapper(e));`
`719`		`- sess.abort_if_errors();`
	`719`	`+ sess.dcx().abort_if_errors();`
`720`	`720`	`}`
`721`	`721`	`}`
`722`	`722`	`}`
`@@ -765,7 +765,7 @@ fn link_natively<'a>(`
`765`	`765`	`}`
`766`	`766`
`767`	`767`	`// May have not found libraries in the right formats.`
`768`		`- sess.abort_if_errors();`
	`768`	`+ sess.dcx().abort_if_errors();`
`769`	`769`
`770`	`770`	`// Invoke the system linker`
`771`	`771`	`info!("{:?}", &cmd);`
`@@ -970,7 +970,7 @@ fn link_natively<'a>(`
`970`	`970`	`}`
`971`	`971`	`}`
`972`	`972`
`973`		`- sess.abort_if_errors();`
	`973`	`+ sess.dcx().abort_if_errors();`
`974`	`974`	`}`
`975`	`975`	`info!("linker stderr:\n{}", escape_string(&prog.stderr));`
`976`	`976`	`info!("linker stdout:\n{}", escape_string(&prog.stdout));`
`@@ -993,7 +993,7 @@ fn link_natively<'a>(`
`993`	`993`	`sess.dcx().emit_note(errors::CheckInstalledVisualStudio);`
`994`	`994`	`sess.dcx().emit_note(errors::InsufficientVSCodeProduct);`
`995`	`995`	`}`
`996`		`- sess.abort_if_errors();`
	`996`	`+ sess.dcx().abort_if_errors();`
`997`	`997`	`}`
`998`	`998`	`}`
`999`	`999`
Original file line number	Diff line number	Diff line change
`@@ -1883,7 +1883,7 @@ impl SharedEmitterMain {`
`1883`	`1883`	`err.emit();`
`1884`	`1884`	`}`
`1885`	`1885`	`Ok(SharedEmitterMessage::AbortIfErrors) => {`
`1886`		`- sess.abort_if_errors();`
	`1886`	`+ sess.dcx().abort_if_errors();`
`1887`	`1887`	`}`
`1888`	`1888`	`Ok(SharedEmitterMessage::Fatal(msg)) => {`
`1889`	`1889`	`sess.dcx().fatal(msg);`
`@@ -1939,15 +1939,15 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {`
`1939`	`1939`	`let compiled_modules = sess.time("join_worker_thread", \|\| match self.coordinator.join() {`
`1940`	`1940`	`Ok(Ok(compiled_modules)) => compiled_modules,`
`1941`	`1941`	`Ok(Err(())) => {`
`1942`		`- sess.abort_if_errors();`
	`1942`	`+ sess.dcx().abort_if_errors();`
`1943`	`1943`	`panic!("expected abort due to worker thread errors")`
`1944`	`1944`	`}`
`1945`	`1945`	`Err(_) => {`
`1946`	`1946`	`bug!("panic during codegen/LLVM phase");`
`1947`	`1947`	`}`
`1948`	`1948`	`});`
`1949`	`1949`
`1950`		`- sess.abort_if_errors();`
	`1950`	`+ sess.dcx().abort_if_errors();`
`1951`	`1951`
`1952`	`1952`	`let work_products =`
`1953`	`1953`	`copy_all_cgu_workproducts_to_incr_comp_cache_dir(sess, &compiled_modules);`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {`
`279`	`279`	`self.tcx.dcx().emit_diagnostic(error);`
`280`	`280`	`}`
`281`	`281`	`} else {`
`282`		`- assert!(self.tcx.sess.has_errors().is_some());`
	`282`	`+ assert!(self.tcx.dcx().has_errors().is_some());`
`283`	`283`	`}`
`284`	`284`	`}`
`285`	`285`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ pub const DEFAULT_BUG_REPORT_URL: &str = "https://github.com/rust-lang/rust/issu`
`150`	`150`	`pub fn abort_on_err<T>(result: Result<T, ErrorGuaranteed>, sess: &Session) -> T {`
`151`	`151`	`match result {`
`152`	`152`	`Err(..) => {`
`153`		`- sess.abort_if_errors();`
	`153`	`+ sess.dcx().abort_if_errors();`
`154`	`154`	`panic!("error reported but abort_if_errors didn't abort???");`
`155`	`155`	`}`
`156`	`156`	`Ok(x) => x,`
Original file line number	Diff line number	Diff line change
`@@ -1284,7 +1284,7 @@ pub(super) fn check_type_params_are_used<'tcx>(`
`1284`	`1284`	`if ty.references_error() {`
`1285`	`1285`	`// If there is already another error, do not emit`
`1286`	`1286`	`// an error for not using a type parameter.`
`1287`		`- assert!(tcx.sess.has_errors().is_some());`
	`1287`	`+ assert!(tcx.dcx().has_errors().is_some());`
`1288`	`1288`	`return;`
`1289`	`1289`	`}`
`1290`	`1290`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {`
`234`	`234`
`235`	`235`	`tcx.ensure().check_unused_traits(());`
`236`	`236`
`237`		`- if let Some(reported) = tcx.sess.has_errors() { Err(reported) } else { Ok(()) }`
	`237`	`+ if let Some(reported) = tcx.dcx().has_errors() { Err(reported) } else { Ok(()) }`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`/// A quasi-deprecated helper used in rustdoc and clippy to get`
Original file line number	Diff line number	Diff line change
`@@ -690,7 +690,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`690`	`690`	`// else an error would have been flagged by the`
`691`	`691`	// `loops` pass for using break with an expression
`692`	`692`	`// where you are not supposed to.`
`693`		`- assert!(expr_opt.is_none() \|\| self.tcx.sess.has_errors().is_some());`
	`693`	`+ assert!(expr_opt.is_none() \|\| self.dcx().has_errors().is_some());`
`694`	`694`	`}`
`695`	`695`
`696`	`696`	// If we encountered a `break`, then (no surprise) it may be possible to break from the
Original file line number	Diff line number	Diff line change
`@@ -576,7 +576,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {`
`576`	`576`	`// struct; however, when EUV is run during typeck, it`
`577`	`577`	`// may not. This will generate an error earlier in typeck,`
`578`	`578`	`// so we can just ignore it.`
`579`		`- if self.tcx().sess.has_errors().is_none() {`
	`579`	`+ if self.tcx().dcx().has_errors().is_none() {`
`580`	`580`	`span_bug!(with_expr.span, "with expression doesn't evaluate to a struct");`
`581`	`581`	`}`
`582`	`582`	`}`
Original file line number	Diff line number	Diff line change
`@@ -753,7 +753,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {`
`753`	`753`	`}`
`754`	`754`
`755`	`755`	`fn report_error(&self, p: impl Into<ty::GenericArg<'tcx>>) -> ErrorGuaranteed {`
`756`		`- match self.fcx.tcx.sess.has_errors() {`
	`756`	`+ match self.fcx.dcx().has_errors() {`
`757`	`757`	`Some(e) => e,`
`758`	`758`	`None => self`
`759`	`759`	`.fcx`