Rename rustc_hir_typeck/src/errors.rs into rustc_hir_typeck/src/diagnostics.rs

Author: GuillaumeGomez

compiler/rustc_hir_typeck/src/_match.rs

@@ -254,7 +254,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
 
         let semi = expr.span.shrink_to_hi().with_hi(semi_span.hi());
-        let sugg = crate::errors::RemoveSemiForCoerce { expr: expr.span, ret, semi };
+        let sugg = crate::diagnostics::RemoveSemiForCoerce { expr: expr.span, ret, semi };
         diag.subdiagnostic(sugg);
     }
 

compiler/rustc_hir_typeck/src/callee.rs

@@ -25,7 +25,7 @@ use tracing::{debug, instrument};
 use super::method::MethodCallee;
 use super::method::probe::ProbeScope;
 use super::{Expectation, FnCtxt, TupleArgumentsFlag};
-use crate::errors;
+use crate::diagnostics;
 use crate::method::TreatNotYetDefinedOpaques;
 use crate::method::confirm::ConfirmContext;
 use crate::method::probe::{IsSuggestion, Mode};
@@ -46,14 +46,14 @@ pub(crate) fn check_legal_trait_for_method_call(
         && !tcx.is_lang_item(tcx.parent(body_id), LangItem::Drop)
     {
         let sugg = if let Some(receiver) = receiver.filter(|s| !s.is_empty()) {
-            errors::ExplicitDestructorCallSugg::Snippet {
+            diagnostics::ExplicitDestructorCallSugg::Snippet {
                 lo: expr_span.shrink_to_lo().to(receiver.shrink_to_lo()),
                 hi: receiver.shrink_to_hi().to(expr_span.shrink_to_hi()),
             }
         } else {
-            errors::ExplicitDestructorCallSugg::Empty(span)
+            diagnostics::ExplicitDestructorCallSugg::Empty(span)
         };
-        return Err(tcx.dcx().emit_err(errors::ExplicitDestructorCall { span, sugg }));
+        return Err(tcx.dcx().emit_err(diagnostics::ExplicitDestructorCall { span, sugg }));
     }
     tcx.ensure_result().coherent_trait(trait_id)
 }
@@ -105,7 +105,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
 
         if self.is_scalable_vector_ctor(autoderef.final_ty()) {
-            let mut err = self.dcx().create_err(errors::ScalableVectorCtor {
+            let mut err = self.dcx().create_err(diagnostics::ScalableVectorCtor {
                 span: callee_expr.span,
                 ty: autoderef.final_ty(),
             });
@@ -190,13 +190,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // The interrupt ABIs should only be called by the CPU. They have complex
             // pre- and postconditions, and can use non-standard instructions like `iret` on x86.
             | CanonAbi::Interrupt(_) => {
-                let err = crate::errors::AbiCannotBeCalled { span, abi };
+                let err = crate::diagnostics::AbiCannotBeCalled { span, abi };
                 self.tcx.dcx().emit_err(err);
             }
 
             // This is an entry point for the host, and cannot be called directly.
             CanonAbi::GpuKernel => {
-                let err = crate::errors::GpuKernelAbiCannotBeCalled { span };
+                let err = crate::diagnostics::GpuKernelAbiCannotBeCalled { span };
                 self.tcx.dcx().emit_err(err);
             }
 
@@ -608,7 +608,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 );
                 self.require_type_is_sized(ty, sp, ObligationCauseCode::RustCall);
             } else {
-                self.dcx().emit_err(errors::RustCallIncorrectArgs { span: sp });
+                self.dcx().emit_err(diagnostics::RustCallIncorrectArgs { span: sp });
             }
         }
 
@@ -845,7 +845,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let callee_ty = self.resolve_vars_if_possible(callee_ty);
         let mut path = None;
-        let mut err = self.dcx().create_err(errors::InvalidCallee {
+        let mut err = self.dcx().create_err(diagnostics::InvalidCallee {
             span: callee_expr.span,
             found: match &unit_variant {
                 Some((_, kind, path)) => format!("{kind} `{path}`"),

compiler/rustc_hir_typeck/src/cast.rs

@@ -49,7 +49,7 @@ use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::{debug, instrument};
 
 use super::FnCtxt;
-use crate::{errors, type_error_struct};
+use crate::{diagnostics, type_error_struct};
 
 /// Reifies a cast check to be checked once we have full type information for
 /// a function context.
@@ -389,13 +389,17 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             CastError::CastToBool => {
                 let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
                 let help = if self.expr_ty.is_numeric() {
-                    errors::CannotCastToBoolHelp::Numeric(
+                    diagnostics::CannotCastToBoolHelp::Numeric(
                         self.expr_span.shrink_to_hi().with_hi(self.span.hi()),
                     )
                 } else {
-                    errors::CannotCastToBoolHelp::Unsupported(self.span)
+                    diagnostics::CannotCastToBoolHelp::Unsupported(self.span)
                 };
-                fcx.dcx().emit_err(errors::CannotCastToBool { span: self.span, expr_ty, help });
+                fcx.dcx().emit_err(diagnostics::CannotCastToBool {
+                    span: self.span,
+                    expr_ty,
+                    help,
+                });
             }
             CastError::CastToChar => {
                 let mut err = type_error_struct!(
@@ -588,7 +592,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             CastError::SizedUnsizedCast => {
                 let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
                 let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
-                fcx.dcx().emit_err(errors::CastThinPointerToWidePointer {
+                fcx.dcx().emit_err(diagnostics::CastThinPointerToWidePointer {
                     span: self.span,
                     expr_ty,
                     cast_ty,
@@ -606,14 +610,14 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                     .then(|| match cast_ty.kind() {
                         ty::RawPtr(pointee, _) => match pointee.kind() {
                             ty::Param(param) => {
-                                Some(errors::IntToWideParamNote { param: param.name })
+                                Some(diagnostics::IntToWideParamNote { param: param.name })
                             }
                             _ => None,
                         },
                         _ => None,
                     })
                     .flatten();
-                fcx.dcx().emit_err(errors::IntToWide {
+                fcx.dcx().emit_err(diagnostics::IntToWide {
                     span,
                     metadata,
                     expr_ty,
@@ -630,17 +634,21 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                     e => unreachable!("control flow means we should never encounter a {e:?}"),
                 };
                 let (span, sub) = if unknown_cast_to {
-                    (self.cast_span, errors::CastUnknownPointerSub::To(self.cast_span))
+                    (self.cast_span, diagnostics::CastUnknownPointerSub::To(self.cast_span))
                 } else {
-                    (self.cast_span, errors::CastUnknownPointerSub::From(self.span))
+                    (self.cast_span, diagnostics::CastUnknownPointerSub::From(self.span))
                 };
-                fcx.dcx().emit_err(errors::CastUnknownPointer { span, to: unknown_cast_to, sub });
+                fcx.dcx().emit_err(diagnostics::CastUnknownPointer {
+                    span,
+                    to: unknown_cast_to,
+                    sub,
+                });
             }
             CastError::CastEnumDrop => {
                 let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
                 let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
 
-                fcx.dcx().emit_err(errors::CastEnumDrop { span: self.span, expr_ty, cast_ty });
+                fcx.dcx().emit_err(diagnostics::CastEnumDrop { span: self.span, expr_ty, cast_ty });
             }
             CastError::ForeignNonExhaustiveAdt => {
                 make_invalid_casting_error(
@@ -653,7 +661,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                 .emit();
             }
             CastError::PtrPtrAddingAutoTrait(added) => {
-                fcx.dcx().emit_err(errors::PtrCastAddAutoToObject {
+                fcx.dcx().emit_err(diagnostics::PtrCastAddAutoToObject {
                     span: self.span,
                     traits_len: added.len(),
                     traits: {
@@ -727,7 +735,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             lint,
             self.expr.hir_id,
             self.span,
-            errors::TrivialCast { numeric, expr_ty, cast_ty },
+            diagnostics::TrivialCast { numeric, expr_ty, cast_ty },
         );
     }
 
@@ -1144,12 +1152,15 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             if let Some((deref_ty, _)) = derefed {
                 // Give a note about what the expr derefs to.
                 if deref_ty != self.expr_ty.peel_refs() {
-                    err.subdiagnostic(errors::DerefImplsIsEmpty { span: self.expr_span, deref_ty });
+                    err.subdiagnostic(diagnostics::DerefImplsIsEmpty {
+                        span: self.expr_span,
+                        deref_ty,
+                    });
                 }
 
                 // Create a multipart suggestion: add `!` and `.is_empty()` in
                 // place of the cast.
-                err.subdiagnostic(errors::UseIsEmpty {
+                err.subdiagnostic(diagnostics::UseIsEmpty {
                     lo: self.expr_span.shrink_to_lo(),
                     hi: self.span.with_lo(self.expr_span.hi()),
                     expr_ty: self.expr_ty,

compiler/rustc_hir_typeck/src/coercion.rs

@@ -67,7 +67,7 @@ use smallvec::{SmallVec, smallvec};
 use tracing::{debug, instrument};
 
 use crate::FnCtxt;
-use crate::errors::SuggestBoxingForReturnImplTrait;
+use crate::diagnostics::SuggestBoxingForReturnImplTrait;
 
 struct Coerce<'a, 'tcx> {
     fcx: &'a FnCtxt<'a, 'tcx>,

compiler/rustc_hir_typeck/src/errors.rs …iler/rustc_hir_typeck/src/diagnostics.rscompiler/rustc_hir_typeck/src/errors.rs renamed to compiler/rustc_hir_typeck/src/diagnostics.rs compiler/rustc_hir_typeck/src/errors.rs renamed to compiler/rustc_hir_typeck/src/diagnostics.rs

@@ -40,7 +40,7 @@ use tracing::{debug, instrument, trace};
 
 use crate::Expectation::{self, ExpectCastableToType, ExpectHasType, NoExpectation};
 use crate::coercion::CoerceMany;
-use crate::errors::{
+use crate::diagnostics::{
     AddressOfTemporaryTaken, BaseExpressionDoubleDot, BaseExpressionDoubleDotAddExpr,
     BaseExpressionDoubleDotRemove, CantDereference, FieldMultiplySpecifiedInInitializer,
     FunctionalRecordUpdateOnNonStruct, HelpUseLatestEdition, NakedAsmOutsideNakedFn,

compiler/rustc_hir_typeck/src/expr.rs

@@ -18,7 +18,7 @@ use rustc_span::{DUMMY_SP, Span};
 use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
 use tracing::debug;
 
-use crate::{FnCtxt, errors};
+use crate::{FnCtxt, diagnostics};
 
 impl<'tcx> FnCtxt<'_, 'tcx> {
     /// Performs type inference fallback, setting [`FnCtxt::diverging_fallback_has_occurred`]
@@ -182,7 +182,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                     FLOAT_LITERAL_F32_FALLBACK,
                     origin.lint_id.unwrap_or(CRATE_HIR_ID),
                     origin.span,
-                    errors::FloatLiteralF32Fallback {
+                    diagnostics::FloatLiteralF32Fallback {
                         span: literal.as_ref().map(|_| origin.span),
                         literal: literal.unwrap_or_default(),
                     },
@@ -312,21 +312,25 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                 span,
                 match reason {
                     UnsafeUseReason::Call => {
-                        errors::NeverTypeFallbackFlowingIntoUnsafe::Call { sugg: sugg.clone() }
+                        diagnostics::NeverTypeFallbackFlowingIntoUnsafe::Call { sugg: sugg.clone() }
                     }
                     UnsafeUseReason::Method => {
-                        errors::NeverTypeFallbackFlowingIntoUnsafe::Method { sugg: sugg.clone() }
+                        diagnostics::NeverTypeFallbackFlowingIntoUnsafe::Method {
+                            sugg: sugg.clone(),
+                        }
                     }
                     UnsafeUseReason::Path => {
-                        errors::NeverTypeFallbackFlowingIntoUnsafe::Path { sugg: sugg.clone() }
+                        diagnostics::NeverTypeFallbackFlowingIntoUnsafe::Path { sugg: sugg.clone() }
                     }
                     UnsafeUseReason::UnionField => {
-                        errors::NeverTypeFallbackFlowingIntoUnsafe::UnionField {
+                        diagnostics::NeverTypeFallbackFlowingIntoUnsafe::UnionField {
                             sugg: sugg.clone(),
                         }
                     }
                     UnsafeUseReason::Deref => {
-                        errors::NeverTypeFallbackFlowingIntoUnsafe::Deref { sugg: sugg.clone() }
+                        diagnostics::NeverTypeFallbackFlowingIntoUnsafe::Deref {
+                            sugg: sugg.clone(),
+                        }
                     }
                 },
             );
@@ -376,7 +380,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                 lint::builtin::DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK,
                 self.tcx.local_def_id_to_hir_id(self.body_id),
                 self.tcx.def_span(self.body_id),
-                errors::DependencyOnUnitNeverTypeFallback {
+                diagnostics::DependencyOnUnitNeverTypeFallback {
                     obligation_span: never_error.obligation.cause.span,
                     obligation: never_error.obligation.predicate,
                     sugg,
@@ -441,7 +445,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         &self,
         diverging_vids: &[ty::TyVid],
         coercions: &VecGraph<ty::TyVid, true>,
-    ) -> errors::SuggestAnnotations {
+    ) -> diagnostics::SuggestAnnotations {
         let body =
             self.tcx.hir_maybe_body_owned_by(self.body_id).expect("body id must have an owner");
         // For each diverging var, look through the HIR for a place to give it
@@ -458,7 +462,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                     .break_value()
             })
             .collect();
-        errors::SuggestAnnotations { suggestions }
+        diagnostics::SuggestAnnotations { suggestions }
     }
 }
 
@@ -479,7 +483,7 @@ impl<'tcx> AnnotateUnitFallbackVisitor<'_, 'tcx> {
         arg_segment: &'tcx hir::PathSegment<'tcx>,
         def_id: DefId,
         id: HirId,
-    ) -> ControlFlow<errors::SuggestAnnotation> {
+    ) -> ControlFlow<diagnostics::SuggestAnnotation> {
         if arg_segment.args.is_none()
             && let Some(all_args) = self.fcx.typeck_results.borrow().node_args_opt(id)
             && let generics = self.fcx.tcx.generics_of(def_id)
@@ -497,7 +501,7 @@ impl<'tcx> AnnotateUnitFallbackVisitor<'_, 'tcx> {
                     && let Some(vid) = self.fcx.root_vid(ty)
                     && self.reachable_vids.contains(&vid)
                 {
-                    return ControlFlow::Break(errors::SuggestAnnotation::Turbo(
+                    return ControlFlow::Break(diagnostics::SuggestAnnotation::Turbo(
                         arg_segment.ident.span.shrink_to_hi(),
                         n_tys,
                         idx,
@@ -509,7 +513,7 @@ impl<'tcx> AnnotateUnitFallbackVisitor<'_, 'tcx> {
     }
 }
 impl<'tcx> Visitor<'tcx> for AnnotateUnitFallbackVisitor<'_, 'tcx> {
-    type Result = ControlFlow<errors::SuggestAnnotation>;
+    type Result = ControlFlow<diagnostics::SuggestAnnotation>;
 
     fn visit_infer(
         &mut self,
@@ -523,7 +527,7 @@ impl<'tcx> Visitor<'tcx> for AnnotateUnitFallbackVisitor<'_, 'tcx> {
             && self.reachable_vids.contains(&vid)
             && inf_span.can_be_used_for_suggestions()
         {
-            return ControlFlow::Break(errors::SuggestAnnotation::Unit(inf_span));
+            return ControlFlow::Break(diagnostics::SuggestAnnotation::Unit(inf_span));
         }
 
         ControlFlow::Continue(())
@@ -570,7 +574,7 @@ impl<'tcx> Visitor<'tcx> for AnnotateUnitFallbackVisitor<'_, 'tcx> {
             && expr.span.can_be_used_for_suggestions()
         {
             let span = path.span.shrink_to_lo().to(trait_segment.ident.span);
-            return ControlFlow::Break(errors::SuggestAnnotation::Path(span));
+            return ControlFlow::Break(diagnostics::SuggestAnnotation::Path(span));
         }
 
         // Or else, try suggesting turbofishing the method args.
@@ -594,7 +598,7 @@ impl<'tcx> Visitor<'tcx> for AnnotateUnitFallbackVisitor<'_, 'tcx> {
             && self.reachable_vids.contains(&vid)
             && local.span.can_be_used_for_suggestions()
         {
-            return ControlFlow::Break(errors::SuggestAnnotation::Local(
+            return ControlFlow::Break(diagnostics::SuggestAnnotation::Local(
                 local.pat.span.shrink_to_hi(),
             ));
         }

compiler/rustc_hir_typeck/src/fallback.rs

@@ -42,7 +42,7 @@ use rustc_trait_selection::traits::{
 use tracing::{debug, instrument};
 
 use crate::callee::{self, DeferredCallResolution};
-use crate::errors::{self, CtorIsPrivate};
+use crate::diagnostics::{self, CtorIsPrivate};
 use crate::method::{self, MethodCallee};
 use crate::{BreakableCtxt, Diverges, Expectation, FnCtxt, LoweredTy};
 
@@ -1158,21 +1158,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             })
             .all(|def_id| def_id != impl_def_id)
             {
-                let sugg = ty.normalized.ty_adt_def().map(|def| errors::ReplaceWithName {
+                let sugg = ty.normalized.ty_adt_def().map(|def| diagnostics::ReplaceWithName {
                     span: path_span,
                     name: self.tcx.item_name(def.did()).to_ident_string(),
                 });
                 let item = match self
                     .tcx
                     .hir_node_by_def_id(self.tcx.hir_get_parent_item(hir_id).def_id)
                 {
-                    hir::Node::Item(item) => Some(errors::InnerItem {
+                    hir::Node::Item(item) => Some(diagnostics::InnerItem {
                         span: item.kind.ident().map(|i| i.span).unwrap_or(item.span),
                     }),
                     _ => None,
                 };
                 if ty.raw.has_param() {
-                    let guar = self.dcx().emit_err(errors::SelfCtorFromOuterItem {
+                    let guar = self.dcx().emit_err(diagnostics::SelfCtorFromOuterItem {
                         span: path_span,
                         impl_span: tcx.def_span(impl_def_id),
                         sugg,
@@ -1184,7 +1184,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
                         hir_id,
                         path_span,
-                        errors::SelfCtorFromOuterItemLint {
+                        diagnostics::SelfCtorFromOuterItemLint {
                             impl_span: tcx.def_span(impl_def_id),
                             sugg,
                             item,