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

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

Follow-up of #157485.

r? @JonathanBrouwer

Author: JonathanBrouwer

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -29,7 +29,7 @@ use super::qualifs::{self, HasMutInterior, NeedsDrop, NeedsNonConstDrop};
 use super::resolver::FlowSensitiveAnalysis;
 use super::{ConstCx, Qualif};
 use crate::check_consts::is_fn_or_trait_safe_to_expose_on_stable;
-use crate::errors;
+use crate::diagnostics;
 
 type QualifResults<'mir, 'tcx, Q> =
     rustc_mir_dataflow::ResultsCursor<'mir, 'tcx, FlowSensitiveAnalysis<'mir, 'tcx, Q>>;
@@ -475,7 +475,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                 if self.enforce_recursive_const_stability()
                     && !is_fn_or_trait_safe_to_expose_on_stable(self.tcx, def_id)
                 {
-                    self.dcx().emit_err(errors::UnmarkedConstItemExposed {
+                    self.dcx().emit_err(diagnostics::UnmarkedConstItemExposed {
                         span: self.span,
                         def_path: self.tcx.def_path_str(def_id),
                     });
@@ -874,7 +874,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             // regular stability, and regular stability is checked separately.
                             // However, we *do* have to worry about *recursive* const stability.
                             if !is_const_stable && self.enforce_recursive_const_stability() {
-                                self.dcx().emit_err(errors::UnmarkedIntrinsicExposed {
+                                self.dcx().emit_err(diagnostics::UnmarkedIntrinsicExposed {
                                     span: self.span,
                                     def_path: self.tcx.def_path_str(callee),
                                 });
@@ -988,7 +988,7 @@ fn emit_unstable_in_stable_exposed_error(
 ) -> ErrorGuaranteed {
     let attr_span = ccx.tcx.def_span(ccx.def_id()).shrink_to_lo();
 
-    ccx.dcx().emit_err(errors::UnstableInStableExposed {
+    ccx.dcx().emit_err(diagnostics::UnstableInStableExposed {
         gate: gate.to_string(),
         span,
         attr_span,

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -23,7 +23,7 @@ use rustc_trait_selection::traits::SelectionContext;
 use tracing::debug;
 
 use super::ConstCx;
-use crate::errors;
+use crate::diagnostics;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Status {
@@ -71,7 +71,7 @@ pub trait NonConstOp<'tcx>: std::fmt::Debug {
 pub(crate) struct FnCallIndirect;
 impl<'tcx> NonConstOp<'tcx> for FnCallIndirect {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::UnallowedFnPointerCall { span, kind: ccx.const_kind() })
+        ccx.dcx().create_err(diagnostics::UnallowedFnPointerCall { span, kind: ccx.const_kind() })
     }
 }
 
@@ -90,7 +90,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallCVariadic {
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
         ccx.tcx.sess.create_feature_err(
-            errors::NonConstCVariadicCall { span, kind: ccx.const_kind() },
+            diagnostics::NonConstCVariadicCall { span, kind: ccx.const_kind() },
             sym::const_c_variadic,
         )
     }
@@ -192,7 +192,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                             // FIXME(const_trait_impl) revisit this
                             if !tcx.is_const_trait_impl(data.impl_def_id) {
                                 let span = tcx.def_span(data.impl_def_id);
-                                err.subdiagnostic(errors::NonConstImplNote { span });
+                                err.subdiagnostic(diagnostics::NonConstImplNote { span });
                             }
                         }
                     }
@@ -235,7 +235,7 @@ fn build_error_for_const_call<'tcx>(
         CallKind::Normal { desugaring: Some((kind, self_ty)), .. } => {
             macro_rules! error {
                 ($err:ident) => {
-                    tcx.dcx().create_err(errors::$err {
+                    tcx.dcx().create_err(diagnostics::$err {
                         span,
                         ty: self_ty,
                         kind: ccx.const_kind(),
@@ -273,14 +273,14 @@ fn build_error_for_const_call<'tcx>(
                         span_bug!(span, "calling const FnDef errored when it shouldn't");
                     }
 
-                    Some(errors::NonConstClosureNote::FnDef { span })
+                    Some(diagnostics::NonConstClosureNote::FnDef { span })
                 }
-                FnPtr(..) => Some(errors::NonConstClosureNote::FnPtr { kind }),
-                Closure(..) => Some(errors::NonConstClosureNote::Closure { kind }),
+                FnPtr(..) => Some(diagnostics::NonConstClosureNote::FnPtr { kind }),
+                Closure(..) => Some(diagnostics::NonConstClosureNote::Closure { kind }),
                 _ => None,
             };
 
-            let mut err = tcx.dcx().create_err(errors::NonConstClosure {
+            let mut err = tcx.dcx().create_err(diagnostics::NonConstClosure {
                 span,
                 kind: ccx.const_kind(),
                 note,
@@ -292,7 +292,7 @@ fn build_error_for_const_call<'tcx>(
         }
         CallKind::Operator { trait_id, self_ty, .. } => {
             let mut err = if let CallSource::MatchCmp = call_source {
-                tcx.dcx().create_err(errors::NonConstMatchEq {
+                tcx.dcx().create_err(diagnostics::NonConstMatchEq {
                     span,
                     kind: ccx.const_kind(),
                     ty: self_ty,
@@ -323,7 +323,7 @@ fn build_error_for_const_call<'tcx>(
                             {
                                 let rhs_pos = span.lo() + BytePos::from_usize(eq_idx + 2 + rhs_idx);
                                 let rhs_span = span.with_lo(rhs_pos).with_hi(rhs_pos);
-                                sugg = Some(errors::ConsiderDereferencing {
+                                sugg = Some(diagnostics::ConsiderDereferencing {
                                     deref,
                                     span: span.shrink_to_lo(),
                                     rhs_span,
@@ -333,7 +333,7 @@ fn build_error_for_const_call<'tcx>(
                         _ => {}
                     }
                 }
-                tcx.dcx().create_err(errors::NonConstOperator {
+                tcx.dcx().create_err(diagnostics::NonConstOperator {
                     span,
                     kind: ccx.const_kind(),
                     sugg,
@@ -354,7 +354,7 @@ fn build_error_for_const_call<'tcx>(
                 None
             };
 
-            let mut err = tcx.dcx().create_err(errors::NonConstDerefCoercion {
+            let mut err = tcx.dcx().create_err(diagnostics::NonConstDerefCoercion {
                 span,
                 ty: self_ty,
                 kind: ccx.const_kind(),
@@ -367,15 +367,15 @@ fn build_error_for_const_call<'tcx>(
             err
         }
         _ if tcx.opt_parent(callee) == tcx.get_diagnostic_item(sym::FmtArgumentsNew) => {
-            ccx.dcx().create_err(errors::NonConstFmtMacroCall {
+            ccx.dcx().create_err(diagnostics::NonConstFmtMacroCall {
                 span,
                 kind: ccx.const_kind(),
                 non_or_conditionally,
             })
         }
         _ => {
             let def_descr = ccx.tcx.def_descr(callee);
-            let mut err = ccx.dcx().create_err(errors::NonConstFnCall {
+            let mut err = ccx.dcx().create_err(diagnostics::NonConstFnCall {
                 span,
                 def_descr,
                 def_path_str: ccx.tcx.def_path_str_with_args(callee, args),
@@ -471,12 +471,12 @@ impl<'tcx> NonConstOp<'tcx> for CallUnstable {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
         assert!(!self.feature_enabled);
         let mut err = if self.is_function_call {
-            ccx.dcx().create_err(errors::UnstableConstFn {
+            ccx.dcx().create_err(diagnostics::UnstableConstFn {
                 span,
                 def_path: ccx.tcx.def_path_str(self.def_id),
             })
         } else {
-            ccx.dcx().create_err(errors::UnstableConstTrait {
+            ccx.dcx().create_err(diagnostics::UnstableConstTrait {
                 span,
                 def_path: ccx.tcx.def_path_str(self.def_id),
             })
@@ -494,7 +494,7 @@ pub(crate) struct IntrinsicNonConst {
 
 impl<'tcx> NonConstOp<'tcx> for IntrinsicNonConst {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::NonConstIntrinsic {
+        ccx.dcx().create_err(diagnostics::NonConstIntrinsic {
             span,
             name: self.name,
             kind: ccx.const_kind(),
@@ -523,7 +523,7 @@ impl<'tcx> NonConstOp<'tcx> for IntrinsicUnstable {
     }
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::UnstableIntrinsic {
+        ccx.dcx().create_err(diagnostics::UnstableIntrinsic {
             span,
             name: self.name,
             feature: self.feature,
@@ -556,9 +556,11 @@ impl<'tcx> NonConstOp<'tcx> for Coroutine {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
         let msg = format!("{} are not allowed in {}s", self.0.to_plural_string(), ccx.const_kind());
         if let Status::Unstable { gate, .. } = self.status_in_item(ccx) {
-            ccx.tcx.sess.create_feature_err(errors::UnallowedOpInConstContext { span, msg }, gate)
+            ccx.tcx
+                .sess
+                .create_feature_err(diagnostics::UnallowedOpInConstContext { span, msg }, gate)
         } else {
-            ccx.dcx().create_err(errors::UnallowedOpInConstContext { span, msg })
+            ccx.dcx().create_err(diagnostics::UnallowedOpInConstContext { span, msg })
         }
     }
 }
@@ -567,7 +569,7 @@ impl<'tcx> NonConstOp<'tcx> for Coroutine {
 pub(crate) struct InlineAsm;
 impl<'tcx> NonConstOp<'tcx> for InlineAsm {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::UnallowedInlineAsm { span, kind: ccx.const_kind() })
+        ccx.dcx().create_err(diagnostics::UnallowedInlineAsm { span, kind: ccx.const_kind() })
     }
 }
 
@@ -593,15 +595,15 @@ impl<'tcx> NonConstOp<'tcx> for LiveDrop<'tcx> {
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
         if self.needs_non_const_drop {
-            ccx.dcx().create_err(errors::LiveDrop {
+            ccx.dcx().create_err(diagnostics::LiveDrop {
                 span,
                 dropped_ty: self.dropped_ty,
                 kind: ccx.const_kind(),
                 dropped_at: self.dropped_at,
             })
         } else {
             ccx.tcx.sess.create_feature_err(
-                errors::LiveDrop {
+                diagnostics::LiveDrop {
                     span,
                     dropped_ty: self.dropped_ty,
                     kind: ccx.const_kind(),
@@ -625,7 +627,8 @@ impl<'tcx> NonConstOp<'tcx> for EscapingCellBorrow {
         DiagImportance::Secondary
     }
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::InteriorMutableBorrowEscaping { span, kind: ccx.const_kind() })
+        ccx.dcx()
+            .create_err(diagnostics::InteriorMutableBorrowEscaping { span, kind: ccx.const_kind() })
     }
 }
 
@@ -647,7 +650,7 @@ impl<'tcx> NonConstOp<'tcx> for EscapingMutBorrow {
     }
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::MutableBorrowEscaping { span, kind: ccx.const_kind() })
+        ccx.dcx().create_err(diagnostics::MutableBorrowEscaping { span, kind: ccx.const_kind() })
     }
 }
 
@@ -656,7 +659,7 @@ impl<'tcx> NonConstOp<'tcx> for EscapingMutBorrow {
 pub(crate) struct PanicNonStr;
 impl<'tcx> NonConstOp<'tcx> for PanicNonStr {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::PanicNonStrErr { span })
+        ccx.dcx().create_err(diagnostics::PanicNonStrErr { span })
     }
 }
 
@@ -668,7 +671,7 @@ pub(crate) struct RawPtrComparison;
 impl<'tcx> NonConstOp<'tcx> for RawPtrComparison {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
         // FIXME(const_trait_impl): revert to span_bug?
-        ccx.dcx().create_err(errors::RawPtrComparisonErr { span })
+        ccx.dcx().create_err(diagnostics::RawPtrComparisonErr { span })
     }
 }
 
@@ -679,7 +682,7 @@ impl<'tcx> NonConstOp<'tcx> for RawPtrComparison {
 pub(crate) struct RawPtrToIntCast;
 impl<'tcx> NonConstOp<'tcx> for RawPtrToIntCast {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::RawPtrToIntErr { span })
+        ccx.dcx().create_err(diagnostics::RawPtrToIntErr { span })
     }
 }
 
@@ -688,6 +691,6 @@ impl<'tcx> NonConstOp<'tcx> for RawPtrToIntCast {
 pub(crate) struct ThreadLocalAccess;
 impl<'tcx> NonConstOp<'tcx> for ThreadLocalAccess {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::ThreadLocalAccessErr { span })
+        ccx.dcx().create_err(diagnostics::ThreadLocalAccessErr { span })
     }
 }

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -11,7 +11,7 @@ use rustc_middle::ty::layout::LayoutError;
 use rustc_span::{DUMMY_SP, Span, Symbol};
 
 use super::CompileTimeMachine;
-use crate::errors::{self, FrameNote};
+use crate::diagnostics::{self, FrameNote};
 use crate::interpret::{
     CtfeProvenance, ErrorHandled, Frame, InterpCx, InterpErrorInfo, InterpErrorKind,
     MachineStopType, Pointer, err_inval, err_machine_stop,
@@ -95,7 +95,7 @@ impl<'tcx> Into<InterpErrorInfo<'tcx>> for ConstEvalErrKind {
 pub(crate) fn get_span_and_frames<'tcx>(
     tcx: TyCtxtAt<'tcx>,
     stack: &[Frame<'tcx, impl Provenance, impl Sized>],
-) -> (Span, Vec<errors::FrameNote>) {
+) -> (Span, Vec<diagnostics::FrameNote>) {
     let mut stacktrace = Frame::generate_stacktrace_from_stack(stack, *tcx);
     // Filter out `requires_caller_location` frames.
     stacktrace.retain(|frame| !frame.instance.def.requires_caller_location(*tcx));
@@ -106,8 +106,8 @@ pub(crate) fn get_span_and_frames<'tcx>(
     // Add notes to the backtrace. Don't print a single-line backtrace though.
     if stacktrace.len() > 1 {
         // Helper closure to print duplicated lines.
-        let mut add_frame = |mut frame: errors::FrameNote| {
-            frames.push(errors::FrameNote { times: 0, ..frame.clone() });
+        let mut add_frame = |mut frame: diagnostics::FrameNote| {
+            frames.push(diagnostics::FrameNote { times: 0, ..frame.clone() });
             // Don't print [... additional calls ...] if the number of lines is small
             if frame.times < 3 {
                 let times = frame.times;
@@ -118,7 +118,7 @@ pub(crate) fn get_span_and_frames<'tcx>(
             }
         };
 
-        let mut last_frame: Option<errors::FrameNote> = None;
+        let mut last_frame: Option<diagnostics::FrameNote> = None;
         for frame_info in &stacktrace {
             let frame = frame_info.as_note(*tcx);
             match last_frame.as_mut() {
@@ -207,7 +207,7 @@ pub(super) fn report<'tcx>(
             {
                 let bytes = ecx.print_alloc_bytes_for_diagnostics(alloc_id);
                 let info = ecx.get_alloc_info(alloc_id);
-                let raw_bytes = errors::RawBytesNote {
+                let raw_bytes = diagnostics::RawBytesNote {
                     size: info.size.bytes(),
                     align: info.align.bytes(),
                     bytes,
@@ -241,7 +241,7 @@ pub(super) fn lint<'tcx, L>(
     tcx: TyCtxtAt<'tcx>,
     machine: &CompileTimeMachine<'tcx>,
     lint: &'static rustc_session::lint::Lint,
-    decorator: impl FnOnce(Vec<errors::FrameNote>) -> L,
+    decorator: impl FnOnce(Vec<diagnostics::FrameNote>) -> L,
 ) where
     L: for<'a> rustc_errors::Diagnostic<'a, ()>,
 {

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -21,7 +21,7 @@ use crate::interpret::{
     InterpResult, MPlaceTy, MemoryKind, OpTy, RefTracking, ReturnContinuation, create_static_alloc,
     intern_const_alloc_recursive, interp_ok, throw_exhaust,
 };
-use crate::{CTRL_C_RECEIVED, errors};
+use crate::{CTRL_C_RECEIVED, diagnostics};
 
 fn retry_codegen_mode_with_postanalysis<'tcx, K: TypeVisitable<TyCtxt<'tcx>>, V>(
     key: ty::PseudoCanonicalInput<'tcx, K>,
@@ -161,28 +161,31 @@ fn intern_and_validate<'tcx, R: InterpretationResult<'tcx>>(
         Ok(()) => {}
         Err(InternError::DanglingPointer) => {
             throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
-                ecx.tcx
-                    .dcx()
-                    .emit_err(errors::DanglingPtrInFinal { span: ecx.tcx.span, kind: intern_kind }),
+                ecx.tcx.dcx().emit_err(diagnostics::DanglingPtrInFinal {
+                    span: ecx.tcx.span,
+                    kind: intern_kind
+                }),
             )));
         }
         Err(InternError::BadMutablePointer) => {
             throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
-                ecx.tcx
-                    .dcx()
-                    .emit_err(errors::MutablePtrInFinal { span: ecx.tcx.span, kind: intern_kind }),
+                ecx.tcx.dcx().emit_err(diagnostics::MutablePtrInFinal {
+                    span: ecx.tcx.span,
+                    kind: intern_kind
+                }),
             )));
         }
         Err(InternError::ConstAllocNotGlobal) => {
             throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
-                ecx.tcx.dcx().emit_err(errors::ConstHeapPtrInFinal { span: ecx.tcx.span }),
+                ecx.tcx.dcx().emit_err(diagnostics::ConstHeapPtrInFinal { span: ecx.tcx.span }),
             )));
         }
         Err(InternError::PartialPointer) => {
             throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
-                ecx.tcx
-                    .dcx()
-                    .emit_err(errors::PartialPtrInFinal { span: ecx.tcx.span, kind: intern_kind }),
+                ecx.tcx.dcx().emit_err(diagnostics::PartialPtrInFinal {
+                    span: ecx.tcx.span,
+                    kind: intern_kind
+                }),
             )));
         }
     }
@@ -532,7 +535,7 @@ fn report_validation_error<'tcx>(
     let bytes = ecx.print_alloc_bytes_for_diagnostics(alloc_id);
     let info = ecx.get_alloc_info(alloc_id);
     let raw_bytes =
-        errors::RawBytesNote { size: info.size.bytes(), align: info.align.bytes(), bytes };
+        diagnostics::RawBytesNote { size: info.size.bytes(), align: info.align.bytes(), bytes };
 
     crate::const_eval::report(ecx, error, move |diag, span, frames| {
         diag.span_label(span, "it is undefined behavior to use this value");