[DO NOT MERGE] Testing #70551 with de-abuse PRs

src/librustc_infer/infer/canonical/mod.rs

@@ -154,7 +154,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                 self.tcx
                     .mk_const(ty::Const {
                         val: ty::ConstKind::Placeholder(placeholder_mapped),
-                        ty: self.tcx.types.err, // FIXME(const_generics)
+                        ty: self.tcx.err(), // FIXME(const_generics)
                     })
                     .into()
             }

src/librustc_infer/infer/mod.rs

@@ -1746,7 +1746,7 @@ impl<'tcx> TypeTrace<'tcx> {
     pub fn dummy(tcx: TyCtxt<'tcx>) -> TypeTrace<'tcx> {
         TypeTrace {
             cause: ObligationCause::dummy(),
-            values: Types(ExpectedFound { expected: tcx.types.err, found: tcx.types.err }),
+            values: Types(ExpectedFound { expected: tcx.err(), found: tcx.err() }),
         }
     }
 }

src/librustc_infer/infer/resolve.rs

@@ -188,15 +188,15 @@ impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
             match t.kind {
                 ty::Infer(ty::TyVar(vid)) => {
                     self.err = Some(FixupError::UnresolvedTy(vid));
-                    self.tcx().types.err
+                    self.tcx().err()
                 }
                 ty::Infer(ty::IntVar(vid)) => {
                     self.err = Some(FixupError::UnresolvedIntTy(vid));
-                    self.tcx().types.err
+                    self.tcx().err()
                 }
                 ty::Infer(ty::FloatVar(vid)) => {
                     self.err = Some(FixupError::UnresolvedFloatTy(vid));
-                    self.tcx().types.err
+                    self.tcx().err()
                 }
                 ty::Infer(_) => {
                     bug!("Unexpected type in full type resolver: {:?}", t);
@@ -227,7 +227,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
             match c.val {
                 ty::ConstKind::Infer(InferConst::Var(vid)) => {
                     self.err = Some(FixupError::UnresolvedConst(vid));
-                    return self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: c.ty });
+                    return self.tcx().err_const(c.ty);
                 }
                 ty::ConstKind::Infer(InferConst::Fresh(_)) => {
                     bug!("Unexpected const in full const resolver: {:?}", c);

src/librustc_infer/infer/sub.rs

@@ -119,7 +119,7 @@ impl TypeRelation<'tcx> for Sub<'combine, 'infcx, 'tcx> {
 
             (&ty::Error, _) | (_, &ty::Error) => {
                 infcx.set_tainted_by_errors();
-                Ok(self.tcx().types.err)
+                Ok(self.tcx().err())
             }
 
             _ => {

src/librustc_middle/lib.rs

@@ -52,6 +52,7 @@
 #![feature(rustc_attrs)]
 #![feature(hash_raw_entry)]
 #![feature(int_error_matching)]
+#![feature(track_caller)]
 #![recursion_limit = "512"]
 
 #[macro_use]

src/librustc_middle/ty/_match.rs

@@ -79,7 +79,7 @@ impl TypeRelation<'tcx> for Match<'tcx> {
                 Err(TypeError::Sorts(relate::expected_found(self, &a, &b)))
             }
 
-            (&ty::Error, _) | (_, &ty::Error) => Ok(self.tcx().types.err),
+            (&ty::Error, _) | (_, &ty::Error) => Ok(self.tcx().err()),
 
             _ => relate::super_relate_tys(self, a, b),
         }

src/librustc_middle/ty/context.rs

@@ -59,7 +59,7 @@ use rustc_session::lint::{Level, Lint};
 use rustc_session::Session;
 use rustc_span::source_map::MultiSpan;
 use rustc_span::symbol::{kw, sym, Symbol};
-use rustc_span::Span;
+use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::{Layout, TargetDataLayout, VariantIdx};
 use rustc_target::spec::abi;
 
@@ -152,7 +152,6 @@ pub struct CommonTypes<'tcx> {
     pub f64: Ty<'tcx>,
     pub never: Ty<'tcx>,
     pub self_param: Ty<'tcx>,
-    pub err: Ty<'tcx>,
 
     /// Dummy type used for the `Self` of a `TraitRef` created for converting
     /// a trait object, and which gets removed in `ExistentialTraitRef`.
@@ -811,7 +810,6 @@ impl<'tcx> CommonTypes<'tcx> {
             bool: mk(Bool),
             char: mk(Char),
             never: mk(Never),
-            err: mk(Error),
             isize: mk(Int(ast::IntTy::Isize)),
             i8: mk(Int(ast::IntTy::I8)),
             i16: mk(Int(ast::IntTy::I16)),
@@ -1180,6 +1178,32 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
+    /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used.
+    #[track_caller]
+    pub fn err(self) -> Ty<'tcx> {
+        self.sess.delay_span_bug(
+            DUMMY_SP,
+            &format!(
+                "TyKind::Error constructed but no error reported. {}",
+                std::panic::Location::caller()
+            ),
+        );
+        self.mk_ty(Error)
+    }
+
+    /// Like `err` but for constants.
+    #[track_caller]
+    pub fn err_const(self, ty: Ty<'tcx>) -> &'tcx Const<'tcx> {
+        self.sess.delay_span_bug(
+            DUMMY_SP,
+            &format!(
+                "ty::ConstKind::Error constructed but no error reported. {}",
+                std::panic::Location::caller()
+            ),
+        );
+        self.mk_const(ty::Const { val: ty::ConstKind::Error, ty })
+    }
+
     pub fn consider_optimizing<T: Fn() -> String>(&self, msg: T) -> bool {
         let cname = self.crate_name(LOCAL_CRATE).as_str();
         self.sess.consider_optimizing(&cname, msg)

src/librustc_middle/ty/query/values.rs

@@ -15,7 +15,7 @@ impl<'tcx, T> Value<'tcx> for T {
 
 impl<'tcx> Value<'tcx> for Ty<'tcx> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
-        tcx.types.err
+        tcx.err()
     }
 }
 
@@ -27,6 +27,6 @@ impl<'tcx> Value<'tcx> for ty::SymbolName {
 
 impl<'tcx> Value<'tcx> for AdtSizedConstraint<'tcx> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self {
-        AdtSizedConstraint(tcx.intern_type_list(&[tcx.types.err]))
+        AdtSizedConstraint(tcx.intern_type_list(&[tcx.err()]))
     }
 }

src/librustc_middle/ty/relate.rs

@@ -354,7 +354,7 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
             bug!("bound types encountered in super_relate_tys")
         }
 
-        (&ty::Error, _) | (_, &ty::Error) => Ok(tcx.types.err),
+        (&ty::Error, _) | (_, &ty::Error) => Ok(tcx.err()),
 
         (&ty::Never, _)
         | (&ty::Char, _)

src/librustc_middle/ty/sty.rs

@@ -2378,9 +2378,7 @@ impl<'tcx> Const<'tcx> {
                 // can leak through `val` into the const we return.
                 Ok(val) => Const::from_value(tcx, val, self.ty),
                 Err(ErrorHandled::TooGeneric | ErrorHandled::Linted) => self,
-                Err(ErrorHandled::Reported(ErrorReported)) => {
-                    tcx.mk_const(ty::Const { val: ty::ConstKind::Error, ty: self.ty })
-                }
+                Err(ErrorHandled::Reported(ErrorReported)) => tcx.err_const(self.ty),
             }
         } else {
             self

src/librustc_mir/borrow_check/type_check/mod.rs

@@ -494,7 +494,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
             if place_ty.variant_index.is_none() {
                 if place_ty.ty.references_error() {
                     assert!(self.errors_reported);
-                    return PlaceTy::from_ty(self.tcx().types.err);
+                    return PlaceTy::from_ty(self.tcx().err());
                 }
             }
             place_ty = self.sanitize_projection(place_ty, elem, place, location)
@@ -721,7 +721,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
 
     fn error(&mut self) -> Ty<'tcx> {
         self.errors_reported = true;
-        self.tcx().types.err
+        self.tcx().err()
     }
 
     fn field_ty(

src/librustc_mir_build/build/mod.rs

@@ -687,7 +687,7 @@ fn construct_error<'a, 'tcx>(hir: Cx<'a, 'tcx>, body_id: hir::BodyId) -> Body<'t
     let tcx = hir.tcx();
     let owner_id = tcx.hir().body_owner(body_id);
     let span = tcx.hir().span(owner_id);
-    let ty = tcx.types.err;
+    let ty = tcx.err();
     let num_params = match hir.body_owner_kind {
         hir::BodyOwnerKind::Fn => tcx.hir().fn_decl_by_hir_id(owner_id).unwrap().inputs.len(),
         hir::BodyOwnerKind::Closure => {