Rollup merge of #157803 - GuillaumeGomez:rename-err-to-diag, r=JonathanBrouwer

Rename `errors.rs` file to `diagnostics.rs` (7/N)

Follow-up of #157485.

r? @JonathanBrouwer

Author: JonathanBrouwer

compiler/rustc_incremental/src/assert_dep_graph.rs

@@ -52,7 +52,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_span::{Span, Symbol, sym};
 use tracing::debug;
 
-use crate::errors;
+use crate::diagnostics;
 
 #[allow(missing_docs)]
 pub(crate) fn assert_dep_graph(tcx: TyCtxt<'_>) {
@@ -128,7 +128,7 @@ impl<'tcx> IfThisChanged<'tcx> {
                             Err(()) => self
                                 .tcx
                                 .dcx()
-                                .emit_fatal(errors::UnrecognizedDepNode { span, name: n }),
+                                .emit_fatal(diagnostics::UnrecognizedDepNode { span, name: n }),
                         }
                     }
                 };
@@ -139,9 +139,10 @@ impl<'tcx> IfThisChanged<'tcx> {
                     let Ok(dep_node) =
                         DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash)
                     else {
-                        self.tcx
-                            .dcx()
-                            .emit_fatal(errors::UnrecognizedDepNode { span: n.span, name: n.name });
+                        self.tcx.dcx().emit_fatal(diagnostics::UnrecognizedDepNode {
+                            span: n.span,
+                            name: n.name,
+                        });
                     };
                     self.then_this_would_need.push((n.span, n.name, hir_id, dep_node));
                 }
@@ -186,7 +187,7 @@ fn check_paths<'tcx>(
 ) {
     if if_this_changed.is_empty() {
         for &(target_span, _, _, _) in then_this_would_need {
-            tcx.dcx().emit_err(errors::MissingIfThisChanged { span: target_span });
+            tcx.dcx().emit_err(diagnostics::MissingIfThisChanged { span: target_span });
         }
         return;
     }
@@ -195,13 +196,13 @@ fn check_paths<'tcx>(
         let dependents = query.transitive_predecessors(source_dep_node);
         for &(target_span, ref target_pass, _, ref target_dep_node) in then_this_would_need {
             if !dependents.contains(&target_dep_node) {
-                tcx.dcx().emit_err(errors::NoPath {
+                tcx.dcx().emit_err(diagnostics::NoPath {
                     span: target_span,
                     source: tcx.def_path_str(source_def_id),
                     target: *target_pass,
                 });
             } else {
-                tcx.dcx().emit_err(errors::Ok { span: target_span });
+                tcx.dcx().emit_err(diagnostics::Ok { span: target_span });
             }
         }
     }

compiler/rustc_incremental/src/errors.rs …ler/rustc_incremental/src/diagnostics.rscompiler/rustc_incremental/src/errors.rs renamed to compiler/rustc_incremental/src/diagnostics.rs compiler/rustc_incremental/src/errors.rs renamed to compiler/rustc_incremental/src/diagnostics.rs

@@ -6,7 +6,7 @@
 // tidy-alphabetical-end
 
 mod assert_dep_graph;
-mod errors;
+mod diagnostics;
 mod persist;
 
 pub use persist::{

compiler/rustc_incremental/src/lib.rs

@@ -33,7 +33,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_span::{Span, Symbol};
 use tracing::debug;
 
-use crate::errors;
+use crate::diagnostics;
 
 // Base and Extra labels to build up the labels
 
@@ -193,7 +193,7 @@ impl<'tcx> CleanVisitor<'tcx> {
         let loaded_from_disk = self.loaded_from_disk(attr);
         for e in except.items().into_sorted_stable_ord() {
             if !auto.remove(e) {
-                self.tcx.dcx().emit_fatal(errors::AssertionAuto { span: attr.span, name, e });
+                self.tcx.dcx().emit_fatal(diagnostics::AssertionAuto { span: attr.span, name, e });
             }
         }
         Assertion { clean: auto, dirty: except, loaded_from_disk }
@@ -267,7 +267,7 @@ impl<'tcx> CleanVisitor<'tcx> {
                     // An implementation, eg `impl<A> Trait for Foo { .. }`
                     HirItem::Impl { .. } => ("ItemKind::Impl", LABELS_IMPL),
 
-                    _ => self.tcx.dcx().emit_fatal(errors::UndefinedCleanDirtyItem {
+                    _ => self.tcx.dcx().emit_fatal(diagnostics::UndefinedCleanDirtyItem {
                         span,
                         kind: format!("{:?}", item.kind),
                     }),
@@ -286,7 +286,7 @@ impl<'tcx> CleanVisitor<'tcx> {
             _ => self
                 .tcx
                 .dcx()
-                .emit_fatal(errors::UndefinedCleanDirty { span, kind: format!("{node:?}") }),
+                .emit_fatal(diagnostics::UndefinedCleanDirty { span, kind: format!("{node:?}") }),
         };
         let labels =
             Labels::from_iter(labels.iter().flat_map(|s| s.iter().map(|l| (*l).to_string())));
@@ -301,13 +301,13 @@ impl<'tcx> CleanVisitor<'tcx> {
                 if out.contains(label_str) {
                     self.tcx
                         .dcx()
-                        .emit_fatal(errors::RepeatedDepNodeLabel { span, label: label_str });
+                        .emit_fatal(diagnostics::RepeatedDepNodeLabel { span, label: label_str });
                 }
                 out.insert(label_str.to_string());
             } else {
                 self.tcx
                     .dcx()
-                    .emit_fatal(errors::UnrecognizedDepNodeLabel { span, label: label_str });
+                    .emit_fatal(diagnostics::UnrecognizedDepNodeLabel { span, label: label_str });
             }
         }
         out
@@ -328,7 +328,7 @@ impl<'tcx> CleanVisitor<'tcx> {
             let dep_node_str = self.dep_node_str(&dep_node);
             self.tcx
                 .dcx()
-                .emit_err(errors::NotDirty { span: item_span, dep_node_str: &dep_node_str });
+                .emit_err(diagnostics::NotDirty { span: item_span, dep_node_str: &dep_node_str });
         }
     }
 
@@ -339,7 +339,7 @@ impl<'tcx> CleanVisitor<'tcx> {
             let dep_node_str = self.dep_node_str(&dep_node);
             self.tcx
                 .dcx()
-                .emit_err(errors::NotClean { span: item_span, dep_node_str: &dep_node_str });
+                .emit_err(diagnostics::NotClean { span: item_span, dep_node_str: &dep_node_str });
         }
     }
 
@@ -369,7 +369,7 @@ impl<'tcx> CleanVisitor<'tcx> {
                     Ok(dep_node) => {
                         if !self.tcx.dep_graph.debug_was_loaded_from_disk(dep_node) {
                             let dep_node_str = self.dep_node_str(&dep_node);
-                            self.tcx.dcx().emit_err(errors::NotLoaded {
+                            self.tcx.dcx().emit_err(diagnostics::NotLoaded {
                                 span: item_span,
                                 dep_node_str: &dep_node_str,
                             });
@@ -379,7 +379,7 @@ impl<'tcx> CleanVisitor<'tcx> {
                     Err(()) => {
                         let dep_kind = dep_kind_from_label(label);
                         if !self.tcx.dep_graph.debug_dep_kind_was_loaded_from_disk(dep_kind) {
-                            self.tcx.dcx().emit_err(errors::NotLoaded {
+                            self.tcx.dcx().emit_err(diagnostics::NotLoaded {
                                 span: item_span,
                                 dep_node_str: &label,
                             });
@@ -407,7 +407,7 @@ impl<'tcx> FindAllAttrs<'tcx> {
     fn report_unchecked_attrs(&self, mut checked_attrs: FxHashSet<Span>) {
         for attr in &self.found_attrs {
             if !checked_attrs.contains(&attr.span) {
-                self.tcx.dcx().emit_err(errors::UncheckedClean { span: attr.span });
+                self.tcx.dcx().emit_err(diagnostics::UncheckedClean { span: attr.span });
                 checked_attrs.insert(attr.span);
             }
         }

compiler/rustc_incremental/src/persist/clean.rs

@@ -20,7 +20,7 @@ use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
 use rustc_session::Session;
 use tracing::debug;
 
-use crate::errors;
+use crate::diagnostics;
 
 /// The first few bytes of files generated by incremental compilation.
 const FILE_MAGIC: &[u8] = b"RSIC";
@@ -57,12 +57,12 @@ where
             debug!("save: remove old file");
         }
         Err(err) if err.kind() == io::ErrorKind::NotFound => (),
-        Err(err) => sess.dcx().emit_fatal(errors::DeleteOld { name, path: path_buf, err }),
+        Err(err) => sess.dcx().emit_fatal(diagnostics::DeleteOld { name, path: path_buf, err }),
     }
 
     let mut encoder = match FileEncoder::new(&path_buf) {
         Ok(encoder) => encoder,
-        Err(err) => sess.dcx().emit_fatal(errors::CreateNew { name, path: path_buf, err }),
+        Err(err) => sess.dcx().emit_fatal(diagnostics::CreateNew { name, path: path_buf, err }),
     };
 
     write_file_header(&mut encoder, sess);
@@ -76,7 +76,7 @@ where
             );
             debug!("save: data written to disk successfully");
         }
-        Err((path, err)) => sess.dcx().emit_fatal(errors::WriteNew { name, path, err }),
+        Err((path, err)) => sess.dcx().emit_fatal(diagnostics::WriteNew { name, path, err }),
     }
 }
 

compiler/rustc_incremental/src/persist/file_format.rs

@@ -120,7 +120,7 @@ use rustc_session::{Session, StableCrateId};
 use rustc_span::Symbol;
 use tracing::debug;
 
-use crate::errors;
+use crate::diagnostics;
 
 #[cfg(test)]
 mod tests;
@@ -233,7 +233,7 @@ pub(crate) fn prepare_session_directory(
     let crate_dir = match try_canonicalize(&crate_dir) {
         Ok(v) => v,
         Err(err) => {
-            sess.dcx().emit_fatal(errors::CanonicalizePath { path: crate_dir, err });
+            sess.dcx().emit_fatal(diagnostics::CanonicalizePath { path: crate_dir, err });
         }
     };
 
@@ -276,7 +276,7 @@ pub(crate) fn prepare_session_directory(
             debug!("successfully copied data from: {}", source_directory.display());
 
             if !allows_links {
-                sess.dcx().emit_warn(errors::HardLinkFailed { path: &session_dir });
+                sess.dcx().emit_warn(diagnostics::HardLinkFailed { path: &session_dir });
             }
 
             sess.init_incr_comp_session(session_dir, directory_lock);
@@ -291,7 +291,7 @@ pub(crate) fn prepare_session_directory(
             // Try to remove the session directory we just allocated. We don't
             // know if there's any garbage in it from the failed copy action.
             if let Err(err) = std_fs::remove_dir_all(&session_dir) {
-                sess.dcx().emit_warn(errors::DeletePartial { path: &session_dir, err });
+                sess.dcx().emit_warn(diagnostics::DeletePartial { path: &session_dir, err });
             }
 
             delete_session_dir_lock_file(sess, &lock_file_path);
@@ -325,7 +325,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
         );
 
         if let Err(err) = std_fs::remove_dir_all(&*incr_comp_session_dir) {
-            sess.dcx().emit_warn(errors::DeleteFull { path: &incr_comp_session_dir, err });
+            sess.dcx().emit_warn(diagnostics::DeleteFull { path: &incr_comp_session_dir, err });
         }
 
         let lock_file_path = lock_file_path(&*incr_comp_session_dir);
@@ -364,7 +364,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
         }
         Err(e) => {
             // Warn about the error. However, no need to abort compilation now.
-            sess.dcx().emit_note(errors::Finalize { path: &incr_comp_session_dir, err: e });
+            sess.dcx().emit_note(diagnostics::Finalize { path: &incr_comp_session_dir, err: e });
 
             debug!("finalize_session_directory() - error, marking as invalid");
             // Drop the file lock, so we can garage collect
@@ -464,7 +464,9 @@ fn create_dir(sess: &Session, path: &Path, dir_tag: &str) {
         Ok(()) => {
             debug!("{} directory created successfully", dir_tag);
         }
-        Err(err) => sess.dcx().emit_fatal(errors::CreateIncrCompDir { tag: dir_tag, path, err }),
+        Err(err) => {
+            sess.dcx().emit_fatal(diagnostics::CreateIncrCompDir { tag: dir_tag, path, err })
+        }
     }
 }
 
@@ -483,7 +485,7 @@ fn lock_directory(sess: &Session, session_dir: &Path) -> (flock::Lock, PathBuf)
         Ok(lock) => (lock, lock_file_path),
         Err(lock_err) => {
             let is_unsupported_lock = flock::Lock::error_unsupported(&lock_err);
-            sess.dcx().emit_fatal(errors::CreateLock {
+            sess.dcx().emit_fatal(diagnostics::CreateLock {
                 lock_err,
                 session_dir,
                 is_unsupported_lock,
@@ -495,7 +497,7 @@ fn lock_directory(sess: &Session, session_dir: &Path) -> (flock::Lock, PathBuf)
 
 fn delete_session_dir_lock_file(sess: &Session, lock_file_path: &Path) {
     if let Err(err) = safe_remove_file(lock_file_path) {
-        sess.dcx().emit_warn(errors::DeleteLock { path: lock_file_path, err });
+        sess.dcx().emit_warn(diagnostics::DeleteLock { path: lock_file_path, err });
     }
 }
 
@@ -708,7 +710,7 @@ pub(crate) fn garbage_collect_session_directories(sess: &Session) -> io::Result<
         if !lock_file_to_session_dir.items().any(|(_, dir)| *dir == directory_name) {
             let path = crate_directory.join(directory_name);
             if let Err(err) = std_fs::remove_dir_all(&path) {
-                sess.dcx().emit_warn(errors::InvalidGcFailed { path: &path, err });
+                sess.dcx().emit_warn(diagnostics::InvalidGcFailed { path: &path, err });
             }
         }
     }
@@ -840,7 +842,7 @@ pub(crate) fn garbage_collect_session_directories(sess: &Session) -> io::Result<
         debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
 
         if let Err(err) = std_fs::remove_dir_all(&path) {
-            sess.dcx().emit_warn(errors::FinalizedGcFailed { path: &path, err });
+            sess.dcx().emit_warn(diagnostics::FinalizedGcFailed { path: &path, err });
         } else {
             delete_session_dir_lock_file(sess, &lock_file_path(&path));
         }
@@ -858,7 +860,7 @@ fn delete_old(sess: &Session, path: &Path) {
     debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
 
     if let Err(err) = std_fs::remove_dir_all(path) {
-        sess.dcx().emit_warn(errors::SessionGcFailed { path, err });
+        sess.dcx().emit_warn(diagnostics::SessionGcFailed { path, err });
     } else {
         delete_session_dir_lock_file(sess, &lock_file_path(path));
     }

compiler/rustc_incremental/src/persist/fs.rs

@@ -18,7 +18,7 @@ use tracing::{debug, warn};
 use super::data::*;
 use super::fs::*;
 use super::{file_format, work_product};
-use crate::errors;
+use crate::diagnostics;
 use crate::persist::file_format::{OpenFile, OpenFileError};
 
 #[derive(Debug)]
@@ -60,7 +60,7 @@ fn load_dep_graph(sess: &Session) -> LoadResult {
         {
             // Decode the list of work_products
             let Ok(mut work_product_decoder) = MemDecoder::new(&mmap[..], start_pos) else {
-                sess.dcx().emit_warn(errors::CorruptFile { path: &work_products_path });
+                sess.dcx().emit_warn(diagnostics::CorruptFile { path: &work_products_path });
                 return LoadResult::DataOutOfDate;
             };
             let work_products: Vec<SerializedWorkProduct> =
@@ -93,7 +93,7 @@ fn load_dep_graph(sess: &Session) -> LoadResult {
         Err(OpenFileError::IoError { err }) => LoadResult::IoError { path: path.to_owned(), err },
         Ok(OpenFile { mmap, start_pos }) => {
             let Ok(mut decoder) = MemDecoder::new(&mmap, start_pos) else {
-                sess.dcx().emit_warn(errors::CorruptFile { path: &path });
+                sess.dcx().emit_warn(diagnostics::CorruptFile { path: &path });
                 return LoadResult::DataOutOfDate;
             };
             let prev_commandline_args_hash = Hash64::decode(&mut decoder);
@@ -135,7 +135,7 @@ pub fn load_query_result_cache(sess: &Session) -> Option<OnDiskCache> {
     match file_format::open_incremental_file(sess, &path) {
         Ok(OpenFile { mmap, start_pos }) => {
             let cache = OnDiskCache::new(sess, mmap, start_pos).unwrap_or_else(|()| {
-                sess.dcx().emit_warn(errors::CorruptFile { path: &path });
+                sess.dcx().emit_warn(diagnostics::CorruptFile { path: &path });
                 OnDiskCache::new_empty()
             });
             Some(cache)
@@ -161,12 +161,12 @@ fn maybe_assert_incr_state(sess: &Session, load_result: &LoadResult) {
     match assertion {
         IncrementalStateAssertion::Loaded => {
             if !loaded {
-                sess.dcx().emit_fatal(errors::AssertLoaded);
+                sess.dcx().emit_fatal(diagnostics::AssertLoaded);
             }
         }
         IncrementalStateAssertion::NotLoaded => {
             if loaded {
-                sess.dcx().emit_fatal(errors::AssertNotLoaded)
+                sess.dcx().emit_fatal(diagnostics::AssertNotLoaded)
             }
         }
     }
@@ -205,12 +205,13 @@ pub fn setup_dep_graph(
 
     let (prev_graph, prev_work_products) = match load_result {
         LoadResult::IoError { path, err } => {
-            sess.dcx().emit_warn(errors::LoadDepGraph { path, err });
+            sess.dcx().emit_warn(diagnostics::LoadDepGraph { path, err });
             Default::default()
         }
         LoadResult::DataOutOfDate => {
             if let Err(err) = delete_all_session_dir_contents(sess) {
-                sess.dcx().emit_err(errors::DeleteIncompatible { path: dep_graph_path(sess), err });
+                sess.dcx()
+                    .emit_err(diagnostics::DeleteIncompatible { path: dep_graph_path(sess), err });
             }
             Default::default()
         }
@@ -223,7 +224,7 @@ pub fn setup_dep_graph(
     let mut encoder = FileEncoder::new(&path_buf).unwrap_or_else(|err| {
         // We're in incremental mode but couldn't set up streaming output of the dep graph.
         // Exit immediately instead of continuing in an inconsistent and untested state.
-        sess.dcx().emit_fatal(errors::CreateDepGraph { path: &path_buf, err })
+        sess.dcx().emit_fatal(diagnostics::CreateDepGraph { path: &path_buf, err })
     });
 
     file_format::write_file_header(&mut encoder, sess);

compiler/rustc_incremental/src/persist/load.rs

@@ -13,7 +13,7 @@ use super::data::*;
 use super::fs::*;
 use super::{clean, file_format, work_product};
 use crate::assert_dep_graph::assert_dep_graph;
-use crate::errors;
+use crate::diagnostics;
 
 /// Saves and writes the [`DepGraph`] to the file system.
 ///
@@ -45,7 +45,7 @@ pub(crate) fn save_dep_graph(tcx: TyCtxt<'_>) {
             move || {
                 sess.time("incr_comp_persist_dep_graph", || {
                     if let Err(err) = fs::rename(&staging_dep_graph_path, &dep_graph_path) {
-                        sess.dcx().emit_err(errors::MoveDepGraph {
+                        sess.dcx().emit_err(diagnostics::MoveDepGraph {
                             from: &staging_dep_graph_path,
                             to: &dep_graph_path,
                             err,