Auto merge of #111570 - compiler-errors:ct-err, r=BoxyUwU

bors · bors · commit 8d18c32b6147 · 2023-05-15T01:03:29.000Z
Rename const error methods for consistency

renames `ty::Const`'s methods for creating a `ConstKind::Error` to be in the same naming style as `ty::Ty`'s equivalent methods.

r? `@BoxyUwU`
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -464,7 +464,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             self.astconv.ct_infer(ty, Some(param), inf.span).into()
                         } else {
                             self.inferred_params.push(inf.span);
-                            tcx.const_error(ty).into()
+                            tcx.const_error_misc(ty).into()
                         }
                     }
                     _ => unreachable!(),
@@ -518,7 +518,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             .no_bound_vars()
                             .expect("const parameter types cannot be generic");
                         if let Err(guar) = ty.error_reported() {
-                            return tcx.const_error_with_guaranteed(ty, guar).into();
+                            return tcx.const_error(ty, guar).into();
                         }
                         if !infer_args && has_default {
                             tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
@@ -527,7 +527,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                                 self.astconv.ct_infer(ty, Some(param), self.span).into()
                             } else {
                                 // We've already errored above about the mismatch.
-                                tcx.const_error(ty).into()
+                                tcx.const_error_misc(ty).into()
                             }
                         }
                     }
@@ -1387,7 +1387,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                         term = match def_kind {
                             hir::def::DefKind::AssocTy => tcx.ty_error(reported).into(),
                             hir::def::DefKind::AssocConst => tcx
-                                .const_error_with_guaranteed(
+                                .const_error(
                                     tcx.type_of(assoc_item_def_id)
                                         .subst(tcx, projection_ty.skip_binder().substs),
                                     reported,
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -836,7 +836,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx> {
                 debug!("Resolver::fold_const: input const `{:?}` not fully resolvable", ct);
                 let e = self.report_error(ct);
                 self.replaced_with_error = Some(e);
-                self.interner().const_error_with_guaranteed(ct.ty(), e)
+                self.interner().const_error(ct.ty(), e)
             }
         }
     }
diff --git a/compiler/rustc_infer/src/infer/combine.rs b/compiler/rustc_infer/src/infer/combine.rs
@@ -209,11 +209,11 @@ impl<'tcx> InferCtxt<'tcx> {
             // HACK: equating both sides with `[const error]` eagerly prevents us
             // from leaving unconstrained inference vars during things like impl
             // matching in the solver.
-            let a_error = self.tcx.const_error_with_guaranteed(a.ty(), guar);
+            let a_error = self.tcx.const_error(a.ty(), guar);
             if let ty::ConstKind::Infer(InferConst::Var(vid)) = a.kind() {
                 return self.unify_const_variable(vid, a_error);
             }
-            let b_error = self.tcx.const_error_with_guaranteed(b.ty(), guar);
+            let b_error = self.tcx.const_error(b.ty(), guar);
             if let ty::ConstKind::Infer(InferConst::Var(vid)) = b.kind() {
                 return self.unify_const_variable(vid, b_error);
             }
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -2330,7 +2330,7 @@ impl<'tcx> ConstantKind<'tcx> {
                 if let Some(val) = c.kind().try_eval_for_mir(tcx, param_env) {
                     match val {
                         Ok(val) => Self::Val(val, c.ty()),
-                        Err(_) => Self::Ty(tcx.const_error(self.ty())),
+                        Err(guar) => Self::Ty(tcx.const_error(self.ty(), guar)),
                     }
                 } else {
                     self
@@ -2342,9 +2342,7 @@ impl<'tcx> ConstantKind<'tcx> {
                 match tcx.const_eval_resolve(param_env, uneval, None) {
                     Ok(val) => Self::Val(val, ty),
                     Err(ErrorHandled::TooGeneric) => self,
-                    Err(ErrorHandled::Reported(guar)) => {
-                        Self::Ty(tcx.const_error_with_guaranteed(ty, guar))
-                    }
+                    Err(ErrorHandled::Reported(guar)) => Self::Ty(tcx.const_error(ty, guar)),
                 }
             }
         }
diff --git a/compiler/rustc_middle/src/ty/abstract_const.rs b/compiler/rustc_middle/src/ty/abstract_const.rs
@@ -53,7 +53,7 @@ impl<'tcx> TyCtxt<'tcx> {
             fn fold_const(&mut self, c: Const<'tcx>) -> Const<'tcx> {
                 let ct = match c.kind() {
                     ty::ConstKind::Unevaluated(uv) => match self.tcx.thir_abstract_const(uv.def) {
-                        Err(e) => self.tcx.const_error_with_guaranteed(c.ty(), e),
+                        Err(e) => self.tcx.const_error(c.ty(), e),
                         Ok(Some(bac)) => {
                             let substs = self.tcx.erase_regions(uv.substs);
                             let bac = bac.subst(self.tcx, substs);
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -142,9 +142,7 @@ impl<'tcx> Const<'tcx> {
                         ty::ConstKind::Bound(debruijn, ty::BoundVar::from_u32(index)),
                         param_ty,
                     )),
-                    Some(rbv::ResolvedArg::Error(guar)) => {
-                        Some(tcx.const_error_with_guaranteed(param_ty, guar))
-                    }
+                    Some(rbv::ResolvedArg::Error(guar)) => Some(tcx.const_error(param_ty, guar)),
                     arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", expr.hir_id),
                 }
             }
@@ -228,7 +226,7 @@ impl<'tcx> Const<'tcx> {
         if let Some(val) = self.kind().try_eval_for_typeck(tcx, param_env) {
             match val {
                 Ok(val) => tcx.mk_const(val, self.ty()),
-                Err(guar) => tcx.const_error_with_guaranteed(self.ty(), guar),
+                Err(guar) => tcx.const_error(self.ty(), guar),
             }
         } else {
             // Either the constant isn't evaluatable or ValTree creation failed.
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -732,17 +732,13 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Like [TyCtxt::ty_error] but for constants, with current `ErrorGuaranteed`
     #[track_caller]
-    pub fn const_error_with_guaranteed(
-        self,
-        ty: Ty<'tcx>,
-        reported: ErrorGuaranteed,
-    ) -> Const<'tcx> {
+    pub fn const_error(self, ty: Ty<'tcx>, reported: ErrorGuaranteed) -> Const<'tcx> {
         self.mk_const(ty::ConstKind::Error(reported), ty)
     }
 
     /// Like [TyCtxt::ty_error] but for constants.
     #[track_caller]
-    pub fn const_error(self, ty: Ty<'tcx>) -> Const<'tcx> {
+    pub fn const_error_misc(self, ty: Ty<'tcx>) -> Const<'tcx> {
         self.const_error_with_message(
             ty,
             DUMMY_SP,
diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
@@ -103,7 +103,7 @@ impl GenericParamDef {
             ty::GenericParamDefKind::Lifetime => tcx.mk_re_error_misc().into(),
             ty::GenericParamDefKind::Type { .. } => tcx.ty_error_misc().into(),
             ty::GenericParamDefKind::Const { .. } => {
-                tcx.const_error(tcx.type_of(self.def_id).subst(tcx, preceding_substs)).into()
+                tcx.const_error_misc(tcx.type_of(self.def_id).subst(tcx, preceding_substs)).into()
             }
         }
     }
diff --git a/compiler/rustc_middle/src/ty/opaque_types.rs b/compiler/rustc_middle/src/ty/opaque_types.rs
@@ -207,14 +207,16 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'tcx> {
                     Some(GenericArgKind::Const(c1)) => c1,
                     Some(u) => panic!("const mapped to unexpected kind: {:?}", u),
                     None => {
-                        if !self.ignore_errors {
-                            self.tcx.sess.emit_err(ConstNotUsedTraitAlias {
+                        let guar = self
+                            .tcx
+                            .sess
+                            .create_err(ConstNotUsedTraitAlias {
                                 ct: ct.to_string(),
                                 span: self.span,
-                            });
-                        }
+                            })
+                            .emit_unless(self.ignore_errors);
 
-                        self.interner().const_error(ct.ty())
+                        self.interner().const_error(ct.ty(), guar)
                     }
                 }
             }
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -52,7 +52,7 @@ pub fn as_constant_inner<'tcx>(
                 match lit_to_mir_constant(tcx, LitToConstInput { lit: &lit.node, ty, neg }) {
                     Ok(c) => c,
                     Err(LitToConstError::Reported(guar)) => {
-                        ConstantKind::Ty(tcx.const_error_with_guaranteed(ty, guar))
+                        ConstantKind::Ty(tcx.const_error(ty, guar))
                     }
                     Err(LitToConstError::TypeError) => {
                         bug!("encountered type error in `lit_to_mir_constant`")
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
@@ -115,9 +115,7 @@ fn recurse_build<'tcx>(
             let sp = node.span;
             match tcx.at(sp).lit_to_const(LitToConstInput { lit: &lit.node, ty: node.ty, neg }) {
                 Ok(c) => c,
-                Err(LitToConstError::Reported(guar)) => {
-                    tcx.const_error_with_guaranteed(node.ty, guar)
-                }
+                Err(LitToConstError::Reported(guar)) => tcx.const_error(node.ty, guar),
                 Err(LitToConstError::TypeError) => {
                     bug!("encountered type error in lit_to_const")
                 }

Original file line number	Diff line number	Diff line change
`@@ -464,7 +464,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`464`	`464`	`self.astconv.ct_infer(ty, Some(param), inf.span).into()`
`465`	`465`	`} else {`
`466`	`466`	`self.inferred_params.push(inf.span);`
`467`		`- tcx.const_error(ty).into()`
	`467`	`+ tcx.const_error_misc(ty).into()`
`468`	`468`	`}`
`469`	`469`	`}`
`470`	`470`	`_ => unreachable!(),`
`@@ -518,7 +518,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`518`	`518`	`.no_bound_vars()`
`519`	`519`	`.expect("const parameter types cannot be generic");`
`520`	`520`	`if let Err(guar) = ty.error_reported() {`
`521`		`- return tcx.const_error_with_guaranteed(ty, guar).into();`
	`521`	`+ return tcx.const_error(ty, guar).into();`
`522`	`522`	`}`
`523`	`523`	`if !infer_args && has_default {`
`524`	`524`	`tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()`
`@@ -527,7 +527,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`527`	`527`	`self.astconv.ct_infer(ty, Some(param), self.span).into()`
`528`	`528`	`} else {`
`529`	`529`	`// We've already errored above about the mismatch.`
`530`		`- tcx.const_error(ty).into()`
	`530`	`+ tcx.const_error_misc(ty).into()`
`531`	`531`	`}`
`532`	`532`	`}`
`533`	`533`	`}`
`@@ -1387,7 +1387,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`1387`	`1387`	`term = match def_kind {`
`1388`	`1388`	`hir::def::DefKind::AssocTy => tcx.ty_error(reported).into(),`
`1389`	`1389`	`hir::def::DefKind::AssocConst => tcx`
`1390`		`- .const_error_with_guaranteed(`
	`1390`	`+ .const_error(`
`1391`	`1391`	`tcx.type_of(assoc_item_def_id)`
`1392`	`1392`	`.subst(tcx, projection_ty.skip_binder().substs),`
`1393`	`1393`	`reported,`
Original file line number	Diff line number	Diff line change
`@@ -836,7 +836,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx> {`
`836`	`836`	debug!("Resolver::fold_const: input const `{:?}` not fully resolvable", ct);
`837`	`837`	`let e = self.report_error(ct);`
`838`	`838`	`self.replaced_with_error = Some(e);`
`839`		`- self.interner().const_error_with_guaranteed(ct.ty(), e)`
	`839`	`+ self.interner().const_error(ct.ty(), e)`
`840`	`840`	`}`
`841`	`841`	`}`
`842`	`842`	`}`
Original file line number	Diff line number	Diff line change
`@@ -209,11 +209,11 @@ impl<'tcx> InferCtxt<'tcx> {`
`209`	`209`	// HACK: equating both sides with `[const error]` eagerly prevents us
`210`	`210`	`// from leaving unconstrained inference vars during things like impl`
`211`	`211`	`// matching in the solver.`
`212`		`- let a_error = self.tcx.const_error_with_guaranteed(a.ty(), guar);`
	`212`	`+ let a_error = self.tcx.const_error(a.ty(), guar);`
`213`	`213`	`if let ty::ConstKind::Infer(InferConst::Var(vid)) = a.kind() {`
`214`	`214`	`return self.unify_const_variable(vid, a_error);`
`215`	`215`	`}`
`216`		`- let b_error = self.tcx.const_error_with_guaranteed(b.ty(), guar);`
	`216`	`+ let b_error = self.tcx.const_error(b.ty(), guar);`
`217`	`217`	`if let ty::ConstKind::Infer(InferConst::Var(vid)) = b.kind() {`
`218`	`218`	`return self.unify_const_variable(vid, b_error);`
`219`	`219`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2330,7 +2330,7 @@ impl<'tcx> ConstantKind<'tcx> {`
`2330`	`2330`	`if let Some(val) = c.kind().try_eval_for_mir(tcx, param_env) {`
`2331`	`2331`	`match val {`
`2332`	`2332`	`Ok(val) => Self::Val(val, c.ty()),`
`2333`		`- Err(_) => Self::Ty(tcx.const_error(self.ty())),`
	`2333`	`+ Err(guar) => Self::Ty(tcx.const_error(self.ty(), guar)),`
`2334`	`2334`	`}`
`2335`	`2335`	`} else {`
`2336`	`2336`	`self`
`@@ -2342,9 +2342,7 @@ impl<'tcx> ConstantKind<'tcx> {`
`2342`	`2342`	`match tcx.const_eval_resolve(param_env, uneval, None) {`
`2343`	`2343`	`Ok(val) => Self::Val(val, ty),`
`2344`	`2344`	`Err(ErrorHandled::TooGeneric) => self,`
`2345`		`- Err(ErrorHandled::Reported(guar)) => {`
`2346`		`- Self::Ty(tcx.const_error_with_guaranteed(ty, guar))`
`2347`		`- }`
	`2345`	`+ Err(ErrorHandled::Reported(guar)) => Self::Ty(tcx.const_error(ty, guar)),`
`2348`	`2346`	`}`
`2349`	`2347`	`}`
`2350`	`2348`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,9 +142,7 @@ impl<'tcx> Const<'tcx> {`
`142`	`142`	`ty::ConstKind::Bound(debruijn, ty::BoundVar::from_u32(index)),`
`143`	`143`	`param_ty,`
`144`	`144`	`)),`
`145`		`- Some(rbv::ResolvedArg::Error(guar)) => {`
`146`		`- Some(tcx.const_error_with_guaranteed(param_ty, guar))`
`147`		`- }`
	`145`	`+ Some(rbv::ResolvedArg::Error(guar)) => Some(tcx.const_error(param_ty, guar)),`
`148`	`146`	`arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", expr.hir_id),`
`149`	`147`	`}`
`150`	`148`	`}`
`@@ -228,7 +226,7 @@ impl<'tcx> Const<'tcx> {`
`228`	`226`	`if let Some(val) = self.kind().try_eval_for_typeck(tcx, param_env) {`
`229`	`227`	`match val {`
`230`	`228`	`Ok(val) => tcx.mk_const(val, self.ty()),`
`231`		`- Err(guar) => tcx.const_error_with_guaranteed(self.ty(), guar),`
	`229`	`+ Err(guar) => tcx.const_error(self.ty(), guar),`
`232`	`230`	`}`
`233`	`231`	`} else {`
`234`	`232`	`// Either the constant isn't evaluatable or ValTree creation failed.`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ impl GenericParamDef {`
`103`	`103`	`ty::GenericParamDefKind::Lifetime => tcx.mk_re_error_misc().into(),`
`104`	`104`	`ty::GenericParamDefKind::Type { .. } => tcx.ty_error_misc().into(),`
`105`	`105`	`ty::GenericParamDefKind::Const { .. } => {`
`106`		`- tcx.const_error(tcx.type_of(self.def_id).subst(tcx, preceding_substs)).into()`
	`106`	`+ tcx.const_error_misc(tcx.type_of(self.def_id).subst(tcx, preceding_substs)).into()`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ pub fn as_constant_inner<'tcx>(`
`52`	`52`	`match lit_to_mir_constant(tcx, LitToConstInput { lit: &lit.node, ty, neg }) {`
`53`	`53`	`Ok(c) => c,`
`54`	`54`	`Err(LitToConstError::Reported(guar)) => {`
`55`		`- ConstantKind::Ty(tcx.const_error_with_guaranteed(ty, guar))`
	`55`	`+ ConstantKind::Ty(tcx.const_error(ty, guar))`
`56`	`56`	`}`
`57`	`57`	`Err(LitToConstError::TypeError) => {`
`58`	`58`	bug!("encountered type error in `lit_to_mir_constant`")