make tykind::error bear a proof and delay span bug

Author: mark-i-m

src/librustc/lib.rs

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

src/librustc/middle/stability.rs

@@ -30,7 +30,11 @@ pub enum StabilityLevel {
 
 impl StabilityLevel {
     pub fn from_attr_level(level: &attr::StabilityLevel) -> Self {
-        if level.is_stable() { Stable } else { Unstable }
+        if level.is_stable() {
+            Stable
+        } else {
+            Unstable
+        }
     }
 }
 
@@ -110,7 +114,11 @@ pub fn report_unstable(
     let span_key = msp.primary_span().and_then(|sp: Span| {
         if !sp.is_dummy() {
             let file = sm.lookup_char_pos(sp.lo()).file;
-            if file.is_imported() { None } else { Some(span) }
+            if file.is_imported() {
+                None
+            } else {
+                Some(span)
+            }
         } else {
             None
         }
@@ -227,7 +235,7 @@ fn late_report_deprecation(
         if let hir::Node::Expr(_) = tcx.hir().get(hir_id) {
             deprecation_suggestion(&mut diag, suggestion, span);
         }
-        diag.emit()
+        diag.emit();
     });
     if hir_id == hir::DUMMY_HIR_ID {
         span_bug!(span, "emitted a {} lint with dummy HIR id: {:?}", lint.name, def_id);
@@ -391,7 +399,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn check_stability(self, def_id: DefId, id: Option<HirId>, span: Span) {
         let soft_handler = |lint, span, msg: &_| {
             self.struct_span_lint_hir(lint, id.unwrap_or(hir::CRATE_HIR_ID), span, |lint| {
-                lint.build(msg).emit()
+                lint.build(msg).emit();
             })
         };
         match self.eval_stability(def_id, id, span) {

src/librustc/mir/interpret/error.rs

@@ -89,7 +89,9 @@ impl<'tcx> ConstEvalErr<'tcx> {
     }
 
     pub fn report_as_error(&self, tcx: TyCtxtAt<'tcx>, message: &str) -> ErrorHandled {
-        match self.struct_error(tcx, message, |mut e| e.emit()) {
+        match self.struct_error(tcx, message, |mut e| {
+            e.emit();
+        }) {
             Ok(_) => ErrorHandled::Reported,
             Err(x) => x,
         }

src/librustc/traits/query.rs

@@ -221,7 +221,7 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         | ty::Ref(..)
         | ty::Str
         | ty::Foreign(..)
-        | ty::Error => true,
+        | ty::Error(..) => true,
 
         // [T; N] and [T] have same properties as T.
         ty::Array(ty, _) | ty::Slice(ty) => trivial_dropck_outlives(tcx, ty),

src/librustc/traits/specialization_graph.rs

@@ -32,12 +32,12 @@ pub struct Graph {
     pub children: DefIdMap<Children>,
 
     /// Whether an error was emitted while constructing the graph.
-    pub has_errored: bool,
+    pub error_reported: Option<ErrorReported>,
 }
 
 impl Graph {
     pub fn new() -> Graph {
-        Graph { parent: Default::default(), children: Default::default(), has_errored: false }
+        Graph { parent: Default::default(), children: Default::default(), error_reported: None }
     }
 
     /// The parent of a given impl, which is the `DefId` of the trait when the
@@ -191,8 +191,8 @@ pub fn ancestors(
     start_from_impl: DefId,
 ) -> Result<Ancestors<'tcx>, ErrorReported> {
     let specialization_graph = tcx.specialization_graph_of(trait_def_id);
-    if specialization_graph.has_errored {
-        Err(ErrorReported)
+    if let Some(error_reported) = specialization_graph.error_reported {
+        Err(error_reported)
     } else {
         Ok(Ancestors {
             trait_def_id,

src/librustc/ty/_match.rs

@@ -76,7 +76,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(proof), _) | (_, &ty::Error(proof)) => Ok(self.tcx().err(proof)),
 
             _ => relate::super_relate_tys(self, a, b),
         }

src/librustc/ty/context.rs

@@ -164,7 +164,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`.
@@ -183,10 +182,6 @@ pub struct CommonLifetimes<'tcx> {
     pub re_erased: Region<'tcx>,
 }
 
-pub struct CommonConsts<'tcx> {
-    pub err: &'tcx Const<'tcx>,
-}
-
 pub struct LocalTableInContext<'a, V> {
     hir_owner: Option<LocalDefId>,
     data: &'a ItemLocalMap<V>,
@@ -821,7 +816,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)),
@@ -855,19 +849,6 @@ impl<'tcx> CommonLifetimes<'tcx> {
     }
 }
 
-impl<'tcx> CommonConsts<'tcx> {
-    fn new(interners: &CtxtInterners<'tcx>, types: &CommonTypes<'tcx>) -> CommonConsts<'tcx> {
-        let mk_const = |c| interners.const_.intern(c, |c| Interned(interners.arena.alloc(c))).0;
-
-        CommonConsts {
-            err: mk_const(ty::Const {
-                val: ty::ConstKind::Value(ConstValue::Scalar(Scalar::zst())),
-                ty: types.err,
-            }),
-        }
-    }
-}
-
 // This struct contains information regarding the `ReFree(FreeRegion)` corresponding to a lifetime
 // conflict.
 #[derive(Debug)]
@@ -925,9 +906,6 @@ pub struct GlobalCtxt<'tcx> {
     /// Common lifetimes, pre-interned for your convenience.
     pub lifetimes: CommonLifetimes<'tcx>,
 
-    /// Common consts, pre-interned for your convenience.
-    pub consts: CommonConsts<'tcx>,
-
     /// Resolutions of `extern crate` items produced by resolver.
     extern_crate_map: NodeMap<CrateNum>,
 
@@ -992,6 +970,34 @@ pub struct GlobalCtxt<'tcx> {
 }
 
 impl<'tcx> TyCtxt<'tcx> {
+    /// Construct an `Error` type. This requires proof that an error has already been emited or
+    /// will be emited.
+    #[track_caller]
+    #[inline]
+    pub fn err(self, proof: rustc_errors::ErrorProof) -> Ty<'tcx> {
+        self.sess.diagnostic().delay_span_bug(
+            rustc_span::DUMMY_SP,
+            &format!("Error constructed but not emited {}", std::panic::Location::caller()),
+        );
+        self.mk_ty(Error(proof))
+    }
+
+    /// Construct an error `const`. This requires proof that an error has already been emited or
+    /// will be emited.
+    #[track_caller]
+    #[inline]
+    pub fn const_err(self, proof: rustc_errors::ErrorProof) -> Const<'tcx> {
+        self.sess.diagnostic().delay_span_bug(
+            rustc_span::DUMMY_SP,
+            &format!("Error `const` constructed but not emited {}", std::panic::Location::caller()),
+        );
+
+        *self.mk_const(ty::Const {
+            val: ty::ConstKind::Value(ConstValue::Scalar(Scalar::zst())),
+            ty: self.err(proof),
+        })
+    }
+
     pub fn alloc_steal_mir(self, mir: BodyAndCache<'tcx>) -> &'tcx Steal<BodyAndCache<'tcx>> {
         self.arena.alloc(Steal::new(mir))
     }
@@ -1096,7 +1102,6 @@ impl<'tcx> TyCtxt<'tcx> {
         let interners = CtxtInterners::new(arena);
         let common_types = CommonTypes::new(&interners);
         let common_lifetimes = CommonLifetimes::new(&interners);
-        let common_consts = CommonConsts::new(&interners, &common_types);
         let cstore = resolutions.cstore;
         let crates = cstore.crates_untracked();
         let max_cnum = crates.iter().map(|c| c.as_usize()).max().unwrap_or(0);
@@ -1146,7 +1151,6 @@ impl<'tcx> TyCtxt<'tcx> {
             prof: s.prof.clone(),
             types: common_types,
             lifetimes: common_lifetimes,
-            consts: common_consts,
             extern_crate_map: resolutions.extern_crate_map,
             trait_map,
             export_map: resolutions
@@ -1840,7 +1844,7 @@ macro_rules! sty_debug_print {
                     let variant = match t.kind {
                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
                             ty::Float(..) | ty::Str | ty::Never => continue,
-                        ty::Error => /* unimportant */ continue,
+                        ty::Error(..) => /* unimportant */ continue,
                         $(ty::$variant(..) => &mut $variant,)*
                     };
                     let lt = t.flags.intersects(ty::TypeFlags::HAS_RE_INFER);

src/librustc/ty/error.rs

@@ -275,14 +275,14 @@ impl<'tcx> ty::TyS<'tcx> {
             ty::UnnormalizedProjection(_) => "non-normalized associated type".into(),
             ty::Param(p) => format!("type parameter `{}`", p).into(),
             ty::Opaque(..) => "opaque type".into(),
-            ty::Error => "type error".into(),
+            ty::Error(..) => "type error".into(),
         }
     }
 
     pub fn prefix_string(&self) -> Cow<'static, str> {
         match self.kind {
             ty::Infer(_)
-            | ty::Error
+            | ty::Error(..)
             | ty::Bool
             | ty::Char
             | ty::Int(_)

src/librustc/ty/fast_reject.rs

@@ -105,7 +105,7 @@ pub fn simplify_type(
         }
         ty::Opaque(def_id, _) => Some(OpaqueSimplifiedType(def_id)),
         ty::Foreign(def_id) => Some(ForeignSimplifiedType(def_id)),
-        ty::Placeholder(..) | ty::Bound(..) | ty::Infer(_) | ty::Error => None,
+        ty::Placeholder(..) | ty::Bound(..) | ty::Infer(_) | ty::Error(..) => None,
     }
 }
 

src/librustc/ty/flags.rs

@@ -77,7 +77,7 @@ impl FlagComputation {
             // But doing so caused sporadic memory corruption, and
             // neither I (tjc) nor nmatsakis could figure out why,
             // so we're doing it this way.
-            &ty::Error => self.add_flags(TypeFlags::HAS_TY_ERR),
+            &ty::Error(..) => self.add_flags(TypeFlags::HAS_TY_ERR),
 
             &ty::Param(_) => {
                 self.add_flags(TypeFlags::HAS_TY_PARAM);

src/librustc/ty/layout.rs

@@ -1249,7 +1249,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             | ty::GeneratorWitness(..)
             | ty::Infer(_) => bug!("LayoutDetails::compute: unexpected type `{}`", ty),
 
-            ty::Param(_) | ty::Error => {
+            ty::Param(_) | ty::Error(..) => {
                 return Err(LayoutError::Unknown(ty));
             }
         })
@@ -2144,7 +2144,7 @@ where
             | ty::Opaque(..)
             | ty::Param(_)
             | ty::Infer(_)
-            | ty::Error => bug!("TyLayout::field_type: unexpected type `{}`", this.ty),
+            | ty::Error(..) => bug!("TyLayout::field_type: unexpected type `{}`", this.ty),
         })
     }
 

src/librustc/ty/outlives.rs

@@ -147,7 +147,7 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
             ty::Dynamic(..) |       // OutlivesObject, OutlivesFragment (*)
             ty::Placeholder(..) |
             ty::Bound(..) |
-            ty::Error => {
+            ty::Error(..) => {
                 // (*) Bare functions and traits are both binders. In the
                 // RFC, this means we would add the bound regions to the
                 // "bound regions list".  In our representation, no such

src/librustc/ty/print/mod.rs

@@ -299,7 +299,7 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
         | ty::Opaque(..)
         | ty::Infer(_)
         | ty::Bound(..)
-        | ty::Error
+        | ty::Error(..)
         | ty::GeneratorWitness(..)
         | ty::Never
         | ty::Float(_) => None,

src/librustc/ty/print/obsolete.rs

@@ -144,7 +144,7 @@ impl DefPathBasedNames<'tcx> {
                 let substs = substs.truncate_to(self.tcx, generics);
                 self.push_generic_params(substs, iter::empty(), output, debug);
             }
-            ty::Error
+            ty::Error(..)
             | ty::Bound(..)
             | ty::Infer(_)
             | ty::Placeholder(..)

src/librustc/ty/print/pretty.rs

@@ -530,7 +530,7 @@ pub trait PrettyPrinter<'tcx>:
                     p!(write("{}", infer_ty))
                 }
             }
-            ty::Error => p!(write("[type error]")),
+            ty::Error(..) => p!(write("[type error]")),
             ty::Param(ref param_ty) => p!(write("{}", param_ty)),
             ty::Bound(debruijn, bound_ty) => match bound_ty.kind {
                 ty::BoundTyKind::Anon => self.pretty_print_bound_var(debruijn, bound_ty.var)?,

src/librustc/ty/query/plumbing.rs

@@ -804,17 +804,17 @@ impl<'tcx> TyCtxt<'tcx> {
 
 macro_rules! handle_cycle_error {
     ([][$tcx: expr, $error:expr]) => {{
-        $tcx.report_cycle($error).emit();
-        Value::from_cycle_error($tcx)
+        let proof = $tcx.report_cycle($error).emit().proof();
+        Value::from_cycle_error($tcx, proof)
     }};
     ([fatal_cycle $($rest:tt)*][$tcx:expr, $error:expr]) => {{
         $tcx.report_cycle($error).emit();
         $tcx.sess.abort_if_errors();
         unreachable!()
     }};
     ([cycle_delay_bug $($rest:tt)*][$tcx:expr, $error:expr]) => {{
-        $tcx.report_cycle($error).delay_as_bug();
-        Value::from_cycle_error($tcx)
+        let proof = $tcx.report_cycle($error).delay_as_bug();
+        Value::from_cycle_error($tcx, proof)
     }};
     ([$other:ident $(($($other_args:tt)*))* $(, $($modifiers:tt)*)*][$($args:tt)*]) => {
         handle_cycle_error!([$($($modifiers)*)*][$($args)*])

src/librustc/ty/query/values.rs

@@ -1,32 +1,33 @@
 use crate::ty::{self, AdtSizedConstraint, Ty, TyCtxt};
 
+use rustc_errors::ErrorProof;
 use rustc_span::symbol::Symbol;
 
 pub(super) trait Value<'tcx>: Sized {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self;
+    fn from_cycle_error(tcx: TyCtxt<'tcx>, proof: ErrorProof) -> Self;
 }
 
 impl<'tcx, T> Value<'tcx> for T {
-    default fn from_cycle_error(tcx: TyCtxt<'tcx>) -> T {
+    default fn from_cycle_error(tcx: TyCtxt<'tcx>, _: ErrorProof) -> T {
         tcx.sess.abort_if_errors();
         bug!("Value::from_cycle_error called without errors");
     }
 }
 
 impl<'tcx> Value<'tcx> for Ty<'tcx> {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
-        tcx.types.err
+    fn from_cycle_error(tcx: TyCtxt<'tcx>, proof: ErrorProof) -> Ty<'tcx> {
+        tcx.err(proof)
     }
 }
 
 impl<'tcx> Value<'tcx> for ty::SymbolName {
-    fn from_cycle_error(_: TyCtxt<'tcx>) -> Self {
+    fn from_cycle_error(_: TyCtxt<'tcx>, _: ErrorProof) -> Self {
         ty::SymbolName { name: Symbol::intern("<error>") }
     }
 }
 
 impl<'tcx> Value<'tcx> for AdtSizedConstraint<'tcx> {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self {
-        AdtSizedConstraint(tcx.intern_type_list(&[tcx.types.err]))
+    fn from_cycle_error(tcx: TyCtxt<'tcx>, proof: ErrorProof) -> Self {
+        AdtSizedConstraint(tcx.intern_type_list(&[tcx.err(proof)]))
     }
 }

src/librustc/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(proof), _) | (_, &ty::Error(proof)) => Ok(tcx.err(proof)),
 
         (&ty::Never, _)
         | (&ty::Char, _)