ty: add ty::ConstKind::Error to replace tcx.consts.err.

eddyb · eddyb · commit 2deb39dd1fd7 · 2020-04-16T19:00:30.000+03:00
diff --git a/src/librustc_infer/infer/freshen.rs b/src/librustc_infer/infer/freshen.rs
@@ -251,7 +251,10 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
                 bug!("unexpected const {:?}", ct)
             }
 
-            ty::ConstKind::Param(_) | ty::ConstKind::Value(_) | ty::ConstKind::Unevaluated(..) => {}
+            ty::ConstKind::Param(_)
+            | ty::ConstKind::Value(_)
+            | ty::ConstKind::Unevaluated(..)
+            | ty::ConstKind::Error => {}
         }
 
         ct.super_fold_with(self)
diff --git a/src/librustc_infer/infer/resolve.rs b/src/librustc_infer/infer/resolve.rs
@@ -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().consts.err;
+                    return self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: c.ty });
                 }
                 ty::ConstKind::Infer(InferConst::Fresh(_)) => {
                     bug!("Unexpected const in full const resolver: {:?}", c);
diff --git a/src/librustc_middle/ty/context.rs b/src/librustc_middle/ty/context.rs
@@ -182,7 +182,7 @@ pub struct CommonLifetimes<'tcx> {
 }
 
 pub struct CommonConsts<'tcx> {
-    pub err: &'tcx Const<'tcx>,
+    pub unit: &'tcx Const<'tcx>,
 }
 
 pub struct LocalTableInContext<'a, V> {
@@ -858,9 +858,9 @@ impl<'tcx> CommonConsts<'tcx> {
         let mk_const = |c| interners.const_.intern(c, |c| Interned(interners.arena.alloc(c))).0;
 
         CommonConsts {
-            err: mk_const(ty::Const {
+            unit: mk_const(ty::Const {
                 val: ty::ConstKind::Value(ConstValue::Scalar(Scalar::zst())),
-                ty: types.err,
+                ty: types.unit,
             }),
         }
     }
diff --git a/src/librustc_middle/ty/flags.rs b/src/librustc_middle/ty/flags.rs
@@ -70,14 +70,7 @@ impl FlagComputation {
             | &ty::Str
             | &ty::Foreign(..) => {}
 
-            // You might think that we could just return Error for
-            // any type containing Error as a component, and get
-            // rid of the TypeFlags::HAS_TY_ERR flag -- likewise for ty_bot (with
-            // the exception of function types that return bot).
-            // 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_ERROR),
 
             &ty::Param(_) => {
                 self.add_flags(TypeFlags::HAS_TY_PARAM);
@@ -239,6 +232,7 @@ impl FlagComputation {
                 self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
             }
             ty::ConstKind::Value(_) => {}
+            ty::ConstKind::Error => self.add_flags(TypeFlags::HAS_ERROR),
         }
     }
 
diff --git a/src/librustc_middle/ty/fold.rs b/src/librustc_middle/ty/fold.rs
@@ -82,7 +82,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
         self.has_type_flags(TypeFlags::HAS_TY_OPAQUE)
     }
     fn references_error(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_TY_ERR)
+        self.has_type_flags(TypeFlags::HAS_ERROR)
     }
     fn has_param_types_or_consts(&self) -> bool {
         self.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_CT_PARAM)
diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs
@@ -567,8 +567,8 @@ bitflags! {
                                           | TypeFlags::HAS_TY_OPAQUE.bits
                                           | TypeFlags::HAS_CT_PROJECTION.bits;
 
-        /// Is an error type reachable?
-        const HAS_TY_ERR                  = 1 << 13;
+        /// Is an error type/const reachable?
+        const HAS_ERROR                   = 1 << 13;
 
         /// Does this have any region that "appears free" in the type?
         /// Basically anything but [ReLateBound] and [ReErased].
diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs
@@ -938,6 +938,7 @@ pub trait PrettyPrinter<'tcx>:
                 self.pretty_print_bound_var(debruijn, bound_var)?
             }
             ty::ConstKind::Placeholder(placeholder) => p!(write("Placeholder({:?})", placeholder)),
+            ty::ConstKind::Error => p!(write("[const error]")),
         };
         Ok(self)
     }
diff --git a/src/librustc_middle/ty/relate.rs b/src/librustc_middle/ty/relate.rs
@@ -510,12 +510,21 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
     let tcx = relation.tcx();
 
     let eagerly_eval = |x: &'tcx ty::Const<'tcx>| {
+        // FIXME(eddyb) this doesn't account for lifetime inference variables
+        // being erased by `eval`, *nor* for the polymorphic aspect of `eval`.
+        // That is, we could always use `eval` and it will just return the
+        // old value back if it doesn't succeed.
         if !x.val.needs_infer() {
             return x.eval(tcx, relation.param_env()).val;
         }
         x.val
     };
 
+    // FIXME(eddyb) doesn't look like everything below checks that `a.ty == b.ty`.
+    // We could probably always assert it early, as `const` generic parameters
+    // are not allowed to depend on other generic parameters, i.e. are concrete.
+    // (although there could be normalization differences)
+
     // Currently, the values that can be unified are primitive types,
     // and those that derive both `PartialEq` and `Eq`, corresponding
     // to structural-match types.
@@ -524,6 +533,9 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
             // The caller should handle these cases!
             bug!("var types encountered in super_relate_consts: {:?} {:?}", a, b)
         }
+
+        (ty::ConstKind::Error, _) | (_, ty::ConstKind::Error) => Ok(ty::ConstKind::Error),
+
         (ty::ConstKind::Param(a_p), ty::ConstKind::Param(b_p)) if a_p.index == b_p.index => {
             return Ok(a);
         }
diff --git a/src/librustc_middle/ty/structural_impls.rs b/src/librustc_middle/ty/structural_impls.rs
@@ -1022,9 +1022,10 @@ impl<'tcx> TypeFoldable<'tcx> for ty::ConstKind<'tcx> {
             ty::ConstKind::Unevaluated(did, substs, promoted) => {
                 ty::ConstKind::Unevaluated(did, substs.fold_with(folder), promoted)
             }
-            ty::ConstKind::Value(_) | ty::ConstKind::Bound(..) | ty::ConstKind::Placeholder(..) => {
-                *self
-            }
+            ty::ConstKind::Value(_)
+            | ty::ConstKind::Bound(..)
+            | ty::ConstKind::Placeholder(..)
+            | ty::ConstKind::Error => *self,
         }
     }
 
@@ -1033,9 +1034,10 @@ impl<'tcx> TypeFoldable<'tcx> for ty::ConstKind<'tcx> {
             ty::ConstKind::Infer(ic) => ic.visit_with(visitor),
             ty::ConstKind::Param(p) => p.visit_with(visitor),
             ty::ConstKind::Unevaluated(_, substs, _) => substs.visit_with(visitor),
-            ty::ConstKind::Value(_) | ty::ConstKind::Bound(..) | ty::ConstKind::Placeholder(_) => {
-                false
-            }
+            ty::ConstKind::Value(_)
+            | ty::ConstKind::Bound(..)
+            | ty::ConstKind::Placeholder(_)
+            | ty::ConstKind::Error => false,
         }
     }
 }
diff --git a/src/librustc_middle/ty/sty.rs b/src/librustc_middle/ty/sty.rs
@@ -2429,6 +2429,10 @@ pub enum ConstKind<'tcx> {
 
     /// Used to hold computed value.
     Value(ConstValue<'tcx>),
+
+    /// A placeholder for a const which could not be computed; this is
+    /// propagated to avoid useless error messages.
+    Error,
 }
 
 #[cfg(target_arch = "x86_64")]
diff --git a/src/librustc_middle/ty/walk.rs b/src/librustc_middle/ty/walk.rs
@@ -170,7 +170,8 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
                 | ty::ConstKind::Param(_)
                 | ty::ConstKind::Placeholder(_)
                 | ty::ConstKind::Bound(..)
-                | ty::ConstKind::Value(_) => {}
+                | ty::ConstKind::Value(_)
+                | ty::ConstKind::Error => {}
 
                 ty::ConstKind::Unevaluated(_, substs, _) => {
                     stack.extend(substs.iter().copied().rev());
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
@@ -518,6 +518,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // Early-return cases.
         let val_val = match val.val {
             ty::ConstKind::Param(_) => throw_inval!(TooGeneric),
+            ty::ConstKind::Error => throw_inval!(TypeckError),
             ty::ConstKind::Unevaluated(def_id, substs, promoted) => {
                 let instance = self.resolve(def_id, substs)?;
                 // We use `const_eval` here and `const_eval_raw` elsewhere in mir interpretation.
diff --git a/src/librustc_trait_selection/opaque_types.rs b/src/librustc_trait_selection/opaque_types.rs
@@ -972,7 +972,7 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> {
                             )
                             .emit();
 
-                        self.tcx().consts.err
+                        self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: ct.ty })
                     }
                 }
             }
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -826,14 +826,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                         }
                     }
                     GenericParamDefKind::Const => {
+                        let ty = tcx.at(span).type_of(param.def_id);
                         // FIXME(const_generics:defaults)
                         if infer_args {
                             // No const parameters were provided, we can infer all.
-                            let ty = tcx.at(span).type_of(param.def_id);
                             self.ct_infer(ty, Some(param), span).into()
                         } else {
                             // We've already errored above about the mismatch.
-                            tcx.consts.err.into()
+                            tcx.mk_const(ty::Const { val: ty::ConstKind::Error, ty }).into()
                         }
                     }
                 }
diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs
@@ -673,7 +673,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Resolver<'cx, 'tcx> {
                 // FIXME: we'd like to use `self.report_error`, but it doesn't yet
                 // accept a &'tcx ty::Const.
                 self.replaced_with_error = true;
-                self.tcx().consts.err
+                self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: ct.ty })
             }
         }
     }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -316,13 +316,13 @@ impl AstConv<'tcx> for ItemCtxt<'tcx> {
 
     fn ct_infer(
         &self,
-        _: Ty<'tcx>,
+        ty: Ty<'tcx>,
         _: Option<&ty::GenericParamDef>,
         span: Span,
     ) -> &'tcx Const<'tcx> {
         bad_placeholder_type(self.tcx(), vec![span]).emit();
 
-        self.tcx().consts.err
+        self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty })
     }
 
     fn projected_ty_from_poly_trait_ref(
@@ -2037,7 +2037,8 @@ fn associated_item_predicates(
             }
             ty::GenericParamDefKind::Const => {
                 unimplemented_error("const");
-                tcx.consts.err.into()
+                tcx.mk_const(ty::Const { val: ty::ConstKind::Error, ty: tcx.type_of(param.def_id) })
+                    .into()
             }
         }
     };

Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,10 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {`
`251`	`251`	`bug!("unexpected const {:?}", ct)`
`252`	`252`	`}`
`253`	`253`
`254`		`- ty::ConstKind::Param(_) \| ty::ConstKind::Value(_) \| ty::ConstKind::Unevaluated(..) => {}`
	`254`	`+ ty::ConstKind::Param(_)`
	`255`	`+ \| ty::ConstKind::Value(_)`
	`256`	`+ \| ty::ConstKind::Unevaluated(..)`
	`257`	`+ \| ty::ConstKind::Error => {}`
`255`	`258`	`}`
`256`	`259`
`257`	`260`	`ct.super_fold_with(self)`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {`
`227`	`227`	`match c.val {`
`228`	`228`	`ty::ConstKind::Infer(InferConst::Var(vid)) => {`
`229`	`229`	`self.err = Some(FixupError::UnresolvedConst(vid));`
`230`		`- return self.tcx().consts.err;`
	`230`	`+ return self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: c.ty });`
`231`	`231`	`}`
`232`	`232`	`ty::ConstKind::Infer(InferConst::Fresh(_)) => {`
`233`	`233`	`bug!("Unexpected const in full const resolver: {:?}", c);`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ pub struct CommonLifetimes<'tcx> {`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`pub struct CommonConsts<'tcx> {`
`185`		`- pub err: &'tcx Const<'tcx>,`
	`185`	`+ pub unit: &'tcx Const<'tcx>,`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`pub struct LocalTableInContext<'a, V> {`
`@@ -858,9 +858,9 @@ impl<'tcx> CommonConsts<'tcx> {`
`858`	`858`	`let mk_const = \|c\| interners.const_.intern(c, \|c\| Interned(interners.arena.alloc(c))).0;`
`859`	`859`
`860`	`860`	`CommonConsts {`
`861`		`- err: mk_const(ty::Const {`
	`861`	`+ unit: mk_const(ty::Const {`
`862`	`862`	`val: ty::ConstKind::Value(ConstValue::Scalar(Scalar::zst())),`
`863`		`- ty: types.err,`
	`863`	`+ ty: types.unit,`
`864`	`864`	`}),`
`865`	`865`	`}`
`866`	`866`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {`
`82`	`82`	`self.has_type_flags(TypeFlags::HAS_TY_OPAQUE)`
`83`	`83`	`}`
`84`	`84`	`fn references_error(&self) -> bool {`
`85`		`- self.has_type_flags(TypeFlags::HAS_TY_ERR)`
	`85`	`+ self.has_type_flags(TypeFlags::HAS_ERROR)`
`86`	`86`	`}`
`87`	`87`	`fn has_param_types_or_consts(&self) -> bool {`
`88`	`88`	`self.has_type_flags(TypeFlags::HAS_TY_PARAM \| TypeFlags::HAS_CT_PARAM)`
Original file line number	Diff line number	Diff line change
`@@ -938,6 +938,7 @@ pub trait PrettyPrinter<'tcx>:`
`938`	`938`	`self.pretty_print_bound_var(debruijn, bound_var)?`
`939`	`939`	`}`
`940`	`940`	`ty::ConstKind::Placeholder(placeholder) => p!(write("Placeholder({:?})", placeholder)),`
	`941`	`+ ty::ConstKind::Error => p!(write("[const error]")),`
`941`	`942`	`};`
`942`	`943`	`Ok(self)`
`943`	`944`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1022,9 +1022,10 @@ impl<'tcx> TypeFoldable<'tcx> for ty::ConstKind<'tcx> {`
`1022`	`1022`	`ty::ConstKind::Unevaluated(did, substs, promoted) => {`
`1023`	`1023`	`ty::ConstKind::Unevaluated(did, substs.fold_with(folder), promoted)`
`1024`	`1024`	`}`
`1025`		`- ty::ConstKind::Value(_) \| ty::ConstKind::Bound(..) \| ty::ConstKind::Placeholder(..) => {`
`1026`		`- *self`
`1027`		`- }`
	`1025`	`+ ty::ConstKind::Value(_)`
	`1026`	`+ \| ty::ConstKind::Bound(..)`
	`1027`	`+ \| ty::ConstKind::Placeholder(..)`
	`1028`	`+ \| ty::ConstKind::Error => *self,`
`1028`	`1029`	`}`
`1029`	`1030`	`}`
`1030`	`1031`
`@@ -1033,9 +1034,10 @@ impl<'tcx> TypeFoldable<'tcx> for ty::ConstKind<'tcx> {`
`1033`	`1034`	`ty::ConstKind::Infer(ic) => ic.visit_with(visitor),`
`1034`	`1035`	`ty::ConstKind::Param(p) => p.visit_with(visitor),`
`1035`	`1036`	`ty::ConstKind::Unevaluated(_, substs, _) => substs.visit_with(visitor),`
`1036`		`- ty::ConstKind::Value(_) \| ty::ConstKind::Bound(..) \| ty::ConstKind::Placeholder(_) => {`
`1037`		`- false`
`1038`		`- }`
	`1037`	`+ ty::ConstKind::Value(_)`
	`1038`	`+ \| ty::ConstKind::Bound(..)`
	`1039`	`+ \| ty::ConstKind::Placeholder(_)`
	`1040`	`+ \| ty::ConstKind::Error => false,`
`1039`	`1041`	`}`
`1040`	`1042`	`}`
`1041`	`1043`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2429,6 +2429,10 @@ pub enum ConstKind<'tcx> {`
`2429`	`2429`
`2430`	`2430`	`/// Used to hold computed value.`
`2431`	`2431`	`Value(ConstValue<'tcx>),`
	`2432`	`+`
	`2433`	`+ /// A placeholder for a const which could not be computed; this is`
	`2434`	`+ /// propagated to avoid useless error messages.`
	`2435`	`+ Error,`
`2432`	`2436`	`}`
`2433`	`2437`
`2434`	`2438`	`#[cfg(target_arch = "x86_64")]`
Original file line number	Diff line number	Diff line change
`@@ -972,7 +972,7 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> {`
`972`	`972`	`)`
`973`	`973`	`.emit();`
`974`	`974`
`975`		`- self.tcx().consts.err`
	`975`	`+ self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: ct.ty })`
`976`	`976`	`}`
`977`	`977`	`}`
`978`	`978`	`}`
Original file line number	Diff line number	Diff line change
`@@ -826,14 +826,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`826`	`826`	`}`
`827`	`827`	`}`
`828`	`828`	`GenericParamDefKind::Const => {`
	`829`	`+ let ty = tcx.at(span).type_of(param.def_id);`
`829`	`830`	`// FIXME(const_generics:defaults)`
`830`	`831`	`if infer_args {`
`831`	`832`	`// No const parameters were provided, we can infer all.`
`832`		`- let ty = tcx.at(span).type_of(param.def_id);`
`833`	`833`	`self.ct_infer(ty, Some(param), span).into()`
`834`	`834`	`} else {`
`835`	`835`	`// We've already errored above about the mismatch.`
`836`		`- tcx.consts.err.into()`
	`836`	`+ tcx.mk_const(ty::Const { val: ty::ConstKind::Error, ty }).into()`
`837`	`837`	`}`
`838`	`838`	`}`
`839`	`839`	`}`
Original file line number	Diff line number	Diff line change
`@@ -673,7 +673,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Resolver<'cx, 'tcx> {`
`673`	`673`	// FIXME: we'd like to use `self.report_error`, but it doesn't yet
`674`	`674`	`// accept a &'tcx ty::Const.`
`675`	`675`	`self.replaced_with_error = true;`
`676`		`- self.tcx().consts.err`
	`676`	`+ self.tcx().mk_const(ty::Const { val: ty::ConstKind::Error, ty: ct.ty })`
`677`	`677`	`}`
`678`	`678`	`}`
`679`	`679`	`}`