Rollup merge of #135195 - oli-obk:push-toyoyrupruko, r=lcnr

Make `lit_to_mir_constant` and `lit_to_const` infallible
My motivation for this change is just that it's annoying to check everywhere, especially since all but one call site was just ICEing on errors anyway right there.
They can still fail, but now just return an error constant instead of having the caller handle the error.
fixes#114317fixes#126182

Author: matthiaskrgr

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -35,7 +35,7 @@ use rustc_hir::{self as hir, AnonConst, GenericArg, GenericArgs, HirId};
 use rustc_infer::infer::{InferCtxt,TyCtxtInferExt};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::middle::stability::AllowUnstable;
-use rustc_middle::mir::interpret::{LitToConstError,LitToConstInput};
+use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::ty::fold::fold_regions;
 use rustc_middle::ty::print::PrintPolyTraitRefExtas _;
 use rustc_middle::ty::{
@@ -2262,25 +2262,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  _ => None,
 };
 
-ifletSome(lit_input) = lit_input {
-// If an error occurred, ignore that it's a literal and leave reporting the error up to
-// mir.
-match tcx.at(expr.span).lit_to_const(lit_input){
-Ok(c) => returnSome(c),
-Err(_)if lit_input.ty.has_aliases() => {
-// allow the `ty` to be an alias type, though we cannot handle it here
-returnNone;
-}
-Err(e) => {
- tcx.dcx().span_delayed_bug(
- expr.span,
-format!("try_lower_anon_const_lit: couldn't lit_to_const {e:?}"),
-);
-}
-}
-}
-
-None
+ lit_input
+// Allow the `ty` to be an alias type, though we cannot handle it here, we just go through
+// the more expensive anon const code path.
+.filter(|l| !l.ty.has_aliases())
+.map(|l| tcx.at(expr.span).lit_to_const(l))
 }
 
 fnlower_delegation_ty(&self,idx: hir::InferDelegationKind) -> Ty<'tcx>{
@@ -2454,13 +2440,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  hir::PatExprKind::Lit{ lit, negated } => {
 let lit_input =
 LitToConstInput{lit:&lit.node, ty,neg: negated };
-let ct = match tcx.lit_to_const(lit_input){
-Ok(c) => c,
-Err(LitToConstError::Reported(err)) => {
- ty::Const::new_error(tcx, err)
-}
-Err(LitToConstError::TypeError) => todo!(),
-};
+let ct = tcx.lit_to_const(lit_input);
 (ct, ty)
 }
 

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -16,7 +16,6 @@ use rustc_abi::{AddressSpace, Align, Endian, HasDataLayout, Size};
 use rustc_ast::{LitKind,Mutability};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lock;
-use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId,LocalDefId};
 use rustc_macros::{HashStable,TyDecodable,TyEncodable,TypeFoldable,TypeVisitable};
@@ -84,16 +83,6 @@ pub struct LitToConstInput<'tcx> {
 pubneg:bool,
 }
 
-/// Error type for `tcx.lit_to_const`.
-#[derive(Copy,Clone,Debug,Eq,PartialEq,HashStable)]
-pubenumLitToConstError{
-/// The literal's inferred type did not match the expected `ty` in the input.
-/// This is used for graceful error handling (`span_delayed_bug`) in
-/// type checking (`Const::from_anon_const`).
-TypeError,
-Reported(ErrorGuaranteed),
-}
-
 #[derive(Copy,Clone,Eq,Hash,Ord,PartialEq,PartialOrd)]
 pubstructAllocId(pubNonZero<u64>);
 

compiler/rustc_middle/src/query/erase.rs

@@ -141,14 +141,6 @@ impl EraseType for Result<rustc_abi::TyAndLayout<'_, Ty<'_>>, &ty::layout::Layou
 >()];
 }
 
-implEraseTypeforResult<ty::Const<'_>, mir::interpret::LitToConstError>{
-typeResult = [u8;size_of::<Result<ty::Const<'static>, mir::interpret::LitToConstError>>()];
-}
-
-implEraseTypeforResult<mir::Const<'_>, mir::interpret::LitToConstError>{
-typeResult = [u8;size_of::<Result<mir::Const<'static>, mir::interpret::LitToConstError>>()];
-}
-
 implEraseTypeforResult<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled>{
 typeResult = [u8;size_of::<Result<mir::ConstAlloc<'static>, mir::interpret::ErrorHandled>>()];
 }
@@ -296,7 +288,6 @@ trivial! {
  rustc_middle::mir::interpret::AllocId,
  rustc_middle::mir::interpret::CtfeProvenance,
  rustc_middle::mir::interpret::ErrorHandled,
- rustc_middle::mir::interpret::LitToConstError,
  rustc_middle::thir::ExprId,
  rustc_middle::traits::CodegenObligationError,
  rustc_middle::traits::EvaluationResult,

compiler/rustc_middle/src/query/mod.rs

@@ -57,7 +57,7 @@ use crate::middle::resolve_bound_vars::{ObjectLifetimeDefault, ResolveBoundVars,
 usecrate::middle::stability::{self,DeprecationEntry};
 usecrate::mir::interpret::{
 EvalStaticInitializerRawResult,EvalToAllocationRawResult,EvalToConstValueResult,
-EvalToValTreeResult,GlobalId,LitToConstError,LitToConstInput,
+EvalToValTreeResult,GlobalId,LitToConstInput,
 };
 usecrate::mir::mono::{CodegenUnit,CollectionMode,MonoItem};
 usecrate::query::erase::{Erase, erase, restore};
@@ -1268,7 +1268,7 @@ rustc_queries! {
 // FIXME get rid of this with valtrees
  query lit_to_const(
  key:LitToConstInput<'tcx>
-) -> Result<ty::Const<'tcx>,LitToConstError> {
+) -> ty::Const<'tcx> {
  desc {"converting literal to const"}
 }
 

compiler/rustc_mir_build/src/builder/expr/as_constant.rs

@@ -3,13 +3,12 @@
 use rustc_abi::Size;
 use rustc_ast as ast;
 use rustc_hir::LangItem;
-use rustc_middle::mir::interpret::{
-Allocation,CTFE_ALLOC_SALT,LitToConstError,LitToConstInput,Scalar,
-};
+use rustc_middle::mir::interpret::{Allocation,CTFE_ALLOC_SALT,LitToConstInput,Scalar};
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
 use rustc_middle::ty::{
-self,CanonicalUserType,CanonicalUserTypeAnnotation,Ty,TyCtxt,UserTypeAnnotationIndex,
+self,CanonicalUserType,CanonicalUserTypeAnnotation,Ty,TyCtxt,TypeVisitableExtas _,
+UserTypeAnnotationIndex,
 };
 use rustc_middle::{bug, mir, span_bug};
 use tracing::{instrument, trace};
@@ -50,16 +49,7 @@ pub(crate) fn as_constant_inner<'tcx>(
 letExpr{ ty,temp_lifetime: _, span,ref kind } = *expr;
 match*kind {
 ExprKind::Literal{ lit, neg } => {
-let const_ = matchlit_to_mir_constant(tcx,LitToConstInput{lit:&lit.node, ty, neg })
-{
-Ok(c) => c,
-Err(LitToConstError::Reported(guar)) => {
-Const::Ty(Ty::new_error(tcx, guar), ty::Const::new_error(tcx, guar))
-}
-Err(LitToConstError::TypeError) => {
-bug!("encountered type error in `lit_to_mir_constant`")
-}
-};
+let const_ = lit_to_mir_constant(tcx,LitToConstInput{lit:&lit.node, ty, neg });
 
 ConstOperand{ span,user_ty:None, const_ }
 }
@@ -108,11 +98,13 @@ pub(crate) fn as_constant_inner<'tcx>(
 }
 
 #[instrument(skip(tcx, lit_input))]
-fnlit_to_mir_constant<'tcx>(
-tcx:TyCtxt<'tcx>,
-lit_input:LitToConstInput<'tcx>,
-) -> Result<Const<'tcx>,LitToConstError>{
+fnlit_to_mir_constant<'tcx>(tcx:TyCtxt<'tcx>,lit_input:LitToConstInput<'tcx>) -> Const<'tcx>{
 letLitToConstInput{ lit, ty, neg } = lit_input;
+
+ifletErr(guar) = ty.error_reported(){
+returnConst::Ty(Ty::new_error(tcx, guar), ty::Const::new_error(tcx, guar));
+}
+
 let trunc = |n| {
 let width = match tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty)){
 Ok(layout) => layout.size,
@@ -123,7 +115,7 @@ fn lit_to_mir_constant<'tcx>(
 trace!("trunc {} with size {} and shift {}", n, width.bits(),128 - width.bits());
 let result = width.truncate(n);
 trace!("trunc result: {}", result);
-Ok(ConstValue::Scalar(Scalar::from_uint(result, width)))
+ConstValue::Scalar(Scalar::from_uint(result, width))
 };
 
 let value = match(lit, ty.kind()){
@@ -154,20 +146,18 @@ fn lit_to_mir_constant<'tcx>(
 ConstValue::Scalar(Scalar::from_uint(*n,Size::from_bytes(1)))
 }
 (ast::LitKind::Int(n, _), ty::Uint(_)) | (ast::LitKind::Int(n, _), ty::Int(_)) => {
-trunc(if neg {(n.get()asi128).overflowing_neg().0asu128}else{ n.get()})?
-}
-(ast::LitKind::Float(n, _), ty::Float(fty)) => parse_float_into_constval(*n,*fty, neg)
-.ok_or_else(|| {
-LitToConstError::Reported(
- tcx.dcx()
-.delayed_bug(format!("couldn't parse float literal: {:?}", lit_input.lit)),
-)
-})?,
+trunc(if neg {(n.get()asi128).overflowing_neg().0asu128}else{ n.get()})
+}
+(ast::LitKind::Float(n, _), ty::Float(fty)) => {
+parse_float_into_constval(*n,*fty, neg).unwrap()
+}
 (ast::LitKind::Bool(b), ty::Bool) => ConstValue::Scalar(Scalar::from_bool(*b)),
 (ast::LitKind::Char(c), ty::Char) => ConstValue::Scalar(Scalar::from_char(*c)),
-(ast::LitKind::Err(guar), _) => returnErr(LitToConstError::Reported(*guar)),
- _ => returnErr(LitToConstError::TypeError),
+(ast::LitKind::Err(guar), _) => {
+returnConst::Ty(Ty::new_error(tcx,*guar), ty::Const::new_error(tcx,*guar));
+}
+ _ => bug!("invalid lit/ty combination in `lit_to_mir_constant`: {lit:?}: {ty:?}"),
 };
 
-Ok(Const::Val(value, ty))
+Const::Val(value, ty)
 }

compiler/rustc_mir_build/src/thir/constant.rs

@@ -1,7 +1,7 @@
 use rustc_ast as ast;
 use rustc_hir::LangItem;
 use rustc_middle::bug;
-use rustc_middle::mir::interpret::{LitToConstError,LitToConstInput};
+use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::ty::{self,ScalarInt,TyCtxt,TypeVisitableExtas _};
 use tracing::trace;
 
@@ -10,11 +10,11 @@ use crate::builder::parse_float_into_scalar;
 pub(crate)fnlit_to_const<'tcx>(
 tcx:TyCtxt<'tcx>,
 lit_input:LitToConstInput<'tcx>,
-) -> Result<ty::Const<'tcx>,LitToConstError>{
+) -> ty::Const<'tcx>{
 letLitToConstInput{ lit, ty, neg } = lit_input;
 
 ifletErr(guar) = ty.error_reported(){
-returnOk(ty::Const::new_error(tcx, guar));
+return ty::Const::new_error(tcx, guar);
 }
 
 let trunc = |n| {
@@ -28,8 +28,8 @@ pub(crate) fn lit_to_const<'tcx>(
 let result = width.truncate(n);
 trace!("trunc result: {}", result);
 
-Ok(ScalarInt::try_from_uint(result, width)
-.unwrap_or_else(|| bug!("expected to create ScalarInt from uint {:?}", result)))
+ScalarInt::try_from_uint(result, width)
+.unwrap_or_else(|| bug!("expected to create ScalarInt from uint {:?}", result))
 };
 
 let valtree = match(lit, ty.kind()){
@@ -57,20 +57,20 @@ pub(crate) fn lit_to_const<'tcx>(
 }
 (ast::LitKind::Int(n, _), ty::Uint(_)) | (ast::LitKind::Int(n, _), ty::Int(_)) => {
 let scalar_int =
-trunc(if neg {(n.get()asi128).overflowing_neg().0asu128}else{ n.get()})?;
+trunc(if neg {(n.get()asi128).overflowing_neg().0asu128}else{ n.get()});
  ty::ValTree::from_scalar_int(scalar_int)
 }
 (ast::LitKind::Bool(b), ty::Bool) => ty::ValTree::from_scalar_int((*b).into()),
 (ast::LitKind::Float(n, _), ty::Float(fty)) => {
-let bits = parse_float_into_scalar(*n,*fty, neg).ok_or_else(|| {
+let bits = parse_float_into_scalar(*n,*fty, neg).unwrap_or_else(|| {
  tcx.dcx().bug(format!("couldn't parse float literal: {:?}", lit_input.lit))
-})?;
+});
  ty::ValTree::from_scalar_int(bits)
 }
 (ast::LitKind::Char(c), ty::Char) => ty::ValTree::from_scalar_int((*c).into()),
-(ast::LitKind::Err(guar), _) => returnErr(LitToConstError::Reported(*guar)),
- _ => returnErr(LitToConstError::TypeError),
+(ast::LitKind::Err(guar), _) => returnty::Const::new_error(tcx,*guar),
+ _ => returnty::Const::new_misc_error(tcx),
 };
 
-Ok(ty::Const::new_value(tcx, valtree, ty))
+ ty::Const::new_value(tcx, valtree, ty)
 }

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -13,7 +13,7 @@ use rustc_hir::pat_util::EnumerateAndAdjustIterator;
 use rustc_hir::{selfas hir,ByRef,Mutability,RangeEnd};
 use rustc_index::Idx;
 use rustc_lint as lint;
-use rustc_middle::mir::interpret::{LitToConstError,LitToConstInput};
+use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::thir::{
 Ascription,FieldPat,LocalVarId,Pat,PatKind,PatRange,PatRangeBoundary,
 };
@@ -669,11 +669,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
 
 let ct_ty = self.typeck_results.node_type(expr.hir_id);
 let lit_input = LitToConstInput{lit:&lit.node,ty: ct_ty, neg };
-matchself.tcx.at(expr.span).lit_to_const(lit_input){
-Ok(constant) => self.const_to_pat(constant, ct_ty, expr.hir_id, lit.span).kind,
-Err(LitToConstError::Reported(e)) => PatKind::Error(e),
-Err(LitToConstError::TypeError) => bug!("lower_lit: had type error"),
-}
+let constant = self.tcx.at(expr.span).lit_to_const(lit_input);
+self.const_to_pat(constant, ct_ty, expr.hir_id, lit.span).kind
 }
 }
 

compiler/rustc_ty_utils/src/consts.rs

@@ -4,7 +4,7 @@ use rustc_abi::{FIRST_VARIANT, VariantIdx};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
-use rustc_middle::mir::interpret::{LitToConstError,LitToConstInput};
+use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::query::Providers;
 use rustc_middle::thir::visit;
 use rustc_middle::thir::visit::Visitor;
@@ -118,13 +118,7 @@ fn recurse_build<'tcx>(
 }
 &ExprKind::Literal{ lit, neg } => {
 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)) => ty::Const::new_error(tcx, guar),
-Err(LitToConstError::TypeError) => {
-bug!("encountered type error in lit_to_const")
-}
-}
+ tcx.at(sp).lit_to_const(LitToConstInput{lit:&lit.node,ty: node.ty, neg })
 }
 &ExprKind::NonHirLiteral{ lit,user_ty: _ } => {
 let val = ty::ValTree::from_scalar_int(lit);