the Const::eval_bits methods don't need to be given the Ty

RalfJung · RalfJung · commit a2374e65aafd · 2023-09-20T07:27:21.000+02:00
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -660,12 +660,12 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
         }
         _ => match ct.ty().kind() {
             ty::Int(ity) => {
-                let bits = ct.eval_bits(tcx, ty::ParamEnv::reveal_all(), ct.ty());
+                let bits = ct.eval_bits(tcx, ty::ParamEnv::reveal_all());
                 let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;
                 write!(output, "{val}")
             }
             ty::Uint(_) => {
-                let val = ct.eval_bits(tcx, ty::ParamEnv::reveal_all(), ct.ty());
+                let val = ct.eval_bits(tcx, ty::ParamEnv::reveal_all());
                 write!(output, "{val}")
             }
             ty::Bool => {
diff --git a/compiler/rustc_const_eval/src/transform/promote_consts.rs b/compiler/rustc_const_eval/src/transform/promote_consts.rs
@@ -554,7 +554,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                             // Integer division: the RHS must be a non-zero const.
                             let const_val = match rhs {
                                 Operand::Constant(c) => {
-                                    c.literal.try_eval_bits(self.tcx, self.param_env, lhs_ty)
+                                    c.literal.try_eval_bits(self.tcx, self.param_env)
                                 }
                                 _ => None,
                             };
diff --git a/compiler/rustc_middle/src/mir/consts.rs b/compiler/rustc_middle/src/mir/consts.rs
@@ -323,23 +323,18 @@ impl<'tcx> ConstantKind<'tcx> {
     }
 
     #[inline]
-    pub fn try_eval_bits(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> Option<u128> {
+    pub fn try_eval_bits(&self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Option<u128> {
         let int = self.try_eval_scalar_int(tcx, param_env)?;
-        assert_eq!(self.ty(), ty);
-        let size = tcx.layout_of(param_env.with_reveal_all_normalized(tcx).and(ty)).ok()?.size;
+        let size =
+            tcx.layout_of(param_env.with_reveal_all_normalized(tcx).and(self.ty())).ok()?.size;
         int.to_bits(size).ok()
     }
 
     /// Panics if the value cannot be evaluated or doesn't contain a valid integer of the given type.
     #[inline]
-    pub fn eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> u128 {
-        self.try_eval_bits(tcx, param_env, ty)
-            .unwrap_or_else(|| bug!("expected bits of {:#?}, got {:#?}", ty, self))
+    pub fn eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> u128 {
+        self.try_eval_bits(tcx, param_env)
+            .unwrap_or_else(|| bug!("expected bits of {:#?}, got {:#?}", self.ty(), self))
     }
 
     #[inline]
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -339,24 +339,19 @@ impl<'tcx> Const<'tcx> {
     /// Attempts to evaluate the given constant to bits. Can fail to evaluate in the presence of
     /// generics (or erroneous code) or if the value can't be represented as bits (e.g. because it
     /// contains const generic parameters or pointers).
-    pub fn try_eval_bits(
-        self,
-        tcx: TyCtxt<'tcx>,
-        param_env: ParamEnv<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> Option<u128> {
+    pub fn try_eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Option<u128> {
         let int = self.try_eval_scalar_int(tcx, param_env)?;
-        assert_eq!(self.ty(), ty);
-        let size = tcx.layout_of(param_env.with_reveal_all_normalized(tcx).and(ty)).ok()?.size;
+        let size =
+            tcx.layout_of(param_env.with_reveal_all_normalized(tcx).and(self.ty())).ok()?.size;
         // if `ty` does not depend on generic parameters, use an empty param_env
         int.to_bits(size).ok()
     }
 
     #[inline]
     /// Panics if the value cannot be evaluated or doesn't contain a valid integer of the given type.
-    pub fn eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>) -> u128 {
-        self.try_eval_bits(tcx, param_env, ty)
-            .unwrap_or_else(|| bug!("expected bits of {:#?}, got {:#?}", ty, self))
+    pub fn eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> u128 {
+        self.try_eval_bits(tcx, param_env)
+            .unwrap_or_else(|| bug!("expected bits of {:#?}, got {:#?}", self.ty(), self))
     }
 
     #[inline]
diff --git a/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs
@@ -100,7 +100,7 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {
                     expected: "constant pattern".to_string(),
                 });
             };
-            values.push(value.eval_bits(self.tcx, self.param_env, arm.pattern.ty));
+            values.push(value.eval_bits(self.tcx, self.param_env));
             targets.push(self.parse_block(arm.body)?);
         }
 
@@ -301,7 +301,7 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {
             | ExprKind::NonHirLiteral { .. }
             | ExprKind::ConstBlock { .. } => Ok({
                 let value = as_constant_inner(expr, |_| None, self.tcx);
-                value.literal.eval_bits(self.tcx, self.param_env, value.ty())
+                value.literal.eval_bits(self.tcx, self.param_env)
             }),
         )
     }
diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs
@@ -1622,9 +1622,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // may want to add cases based on the candidates that are
         // available
         match test.kind {
-            TestKind::SwitchInt { switch_ty, ref mut options } => {
+            TestKind::SwitchInt { switch_ty: _, ref mut options } => {
                 for candidate in candidates.iter() {
-                    if !self.add_cases_to_switch(&match_place, candidate, switch_ty, options) {
+                    if !self.add_cases_to_switch(&match_place, candidate, options) {
                         break;
                     }
                 }
diff --git a/compiler/rustc_mir_build/src/build/matches/test.rs b/compiler/rustc_mir_build/src/build/matches/test.rs
@@ -85,7 +85,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         &mut self,
         test_place: &PlaceBuilder<'tcx>,
         candidate: &Candidate<'pat, 'tcx>,
-        switch_ty: Ty<'tcx>,
         options: &mut FxIndexMap<ConstantKind<'tcx>, u128>,
     ) -> bool {
         let Some(match_pair) = candidate.match_pairs.iter().find(|mp| mp.place == *test_place)
@@ -95,9 +94,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         match match_pair.pattern.kind {
             PatKind::Constant { value } => {
-                options
-                    .entry(value)
-                    .or_insert_with(|| value.eval_bits(self.tcx, self.param_env, switch_ty));
+                options.entry(value).or_insert_with(|| value.eval_bits(self.tcx, self.param_env));
                 true
             }
             PatKind::Variant { .. } => {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs
@@ -146,7 +146,7 @@ impl IntRange {
                 valtree.unwrap_leaf().to_bits(target_size).ok()
             },
             // This is a more general form of the previous case.
-            _ => value.try_eval_bits(tcx, param_env, ty),
+            _ => value.try_eval_bits(tcx, param_env),
         }?;
 
         let val = val ^ bias;
@@ -1379,8 +1379,8 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
                 let ty = lo.ty();
                 ctor = if let Some(int_range) = IntRange::from_range(
                     cx.tcx,
-                    lo.eval_bits(cx.tcx, cx.param_env, lo.ty()),
-                    hi.eval_bits(cx.tcx, cx.param_env, hi.ty()),
+                    lo.eval_bits(cx.tcx, cx.param_env),
+                    hi.eval_bits(cx.tcx, cx.param_env),
                     ty,
                     &end,
                 ) {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -131,15 +131,15 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = lo_expr
                     && let rustc_ast::ast::LitKind::Int(val, _) = lit.node
                 {
-                    if lo.eval_bits(self.tcx, self.param_env, ty) != val {
+                    if lo.eval_bits(self.tcx, self.param_env) != val {
                         lower_overflow = true;
                         self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });
                     }
                 }
                 if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = hi_expr
                     && let rustc_ast::ast::LitKind::Int(val, _) = lit.node
                 {
-                    if hi.eval_bits(self.tcx, self.param_env, ty) != val {
+                    if hi.eval_bits(self.tcx, self.param_env) != val {
                         higher_overflow = true;
                         self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });
                     }
@@ -162,15 +162,15 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = lo_expr
                     && let rustc_ast::ast::LitKind::Int(val, _) = lit.node
                 {
-                    if lo.eval_bits(self.tcx, self.param_env, ty) != val {
+                    if lo.eval_bits(self.tcx, self.param_env) != val {
                         lower_overflow = true;
                         self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });
                     }
                 }
                 if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = hi_expr
                     && let rustc_ast::ast::LitKind::Int(val, _) = lit.node
                 {
-                    if hi.eval_bits(self.tcx, self.param_env, ty) != val {
+                    if hi.eval_bits(self.tcx, self.param_env) != val {
                         higher_overflow = true;
                         self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });
                     }
@@ -865,8 +865,8 @@ pub(crate) fn compare_const_vals<'tcx>(
         },
     }
 
-    let a = a.eval_bits(tcx, param_env, ty);
-    let b = b.eval_bits(tcx, param_env, ty);
+    let a = a.eval_bits(tcx, param_env);
+    let b = b.eval_bits(tcx, param_env);
 
     use rustc_apfloat::Float;
     match *ty.kind() {
diff --git a/compiler/rustc_mir_transform/src/const_goto.rs b/compiler/rustc_mir_transform/src/const_goto.rs
@@ -96,10 +96,10 @@ impl<'tcx> Visitor<'tcx> for ConstGotoOptimizationFinder<'_, 'tcx> {
                 let (discr, targets) = target_bb_terminator.kind.as_switch()?;
                 if discr.place() == Some(*place) {
                     let switch_ty = place.ty(self.body.local_decls(), self.tcx).ty;
+                    debug_assert_eq!(switch_ty, _const.ty());
                     // We now know that the Switch matches on the const place, and it is statementless
                     // Now find which value in the Switch matches the const value.
-                    let const_value =
-                        _const.literal.try_eval_bits(self.tcx, self.param_env, switch_ty)?;
+                    let const_value = _const.literal.try_eval_bits(self.tcx, self.param_env)?;
                     let target_to_use_in_goto = targets.target_for_value(const_value);
                     self.optimizations.push(OptimizationToApply {
                         bb_with_goto: location.block,
diff --git a/compiler/rustc_mir_transform/src/simplify_branches.rs b/compiler/rustc_mir_transform/src/simplify_branches.rs
@@ -23,7 +23,7 @@ impl<'tcx> MirPass<'tcx> for SimplifyConstCondition {
                 TerminatorKind::SwitchInt {
                     discr: Operand::Constant(ref c), ref targets, ..
                 } => {
-                    let constant = c.literal.try_eval_bits(tcx, param_env, c.ty());
+                    let constant = c.literal.try_eval_bits(tcx, param_env);
                     if let Some(constant) = constant {
                         let target = targets.target_for_value(constant);
                         TerminatorKind::Goto { target }
diff --git a/compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs b/compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
@@ -118,15 +118,15 @@ fn encode_const<'tcx>(
             // bool value false is encoded as 0 and true as 1.
             match c.ty().kind() {
                 ty::Int(ity) => {
-                    let bits = c.eval_bits(tcx, ty::ParamEnv::reveal_all(), c.ty());
+                    let bits = c.eval_bits(tcx, ty::ParamEnv::reveal_all());
                     let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;
                     if val < 0 {
                         s.push('n');
                     }
                     let _ = write!(s, "{val}");
                 }
                 ty::Uint(_) => {
-                    let val = c.eval_bits(tcx, ty::ParamEnv::reveal_all(), c.ty());
+                    let val = c.eval_bits(tcx, ty::ParamEnv::reveal_all());
                     let _ = write!(s, "{val}");
                 }
                 ty::Bool => {
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -594,7 +594,7 @@ impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx> {
             ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => {
                 self = ty.print(self)?;
 
-                let mut bits = ct.eval_bits(self.tcx, ty::ParamEnv::reveal_all(), ty);
+                let mut bits = ct.eval_bits(self.tcx, ty::ParamEnv::reveal_all());
 
                 // Negative integer values are mangled using `n` as a "sign prefix".
                 if let ty::Int(ity) = ty.kind() {

Original file line number	Diff line number	Diff line change
`@@ -660,12 +660,12 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S`
`660`	`660`	`}`
`661`	`661`	`_ => match ct.ty().kind() {`
`662`	`662`	`ty::Int(ity) => {`
`663`		`- let bits = ct.eval_bits(tcx, ty::ParamEnv::reveal_all(), ct.ty());`
	`663`	`+ let bits = ct.eval_bits(tcx, ty::ParamEnv::reveal_all());`
`664`	`664`	`let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;`
`665`	`665`	`write!(output, "{val}")`
`666`	`666`	`}`
`667`	`667`	`ty::Uint(_) => {`
`668`		`- let val = ct.eval_bits(tcx, ty::ParamEnv::reveal_all(), ct.ty());`
	`668`	`+ let val = ct.eval_bits(tcx, ty::ParamEnv::reveal_all());`
`669`	`669`	`write!(output, "{val}")`
`670`	`670`	`}`
`671`	`671`	`ty::Bool => {`
Original file line number	Diff line number	Diff line change
`@@ -554,7 +554,7 @@ impl<'tcx> Validator<'_, 'tcx> {`
`554`	`554`	`// Integer division: the RHS must be a non-zero const.`
`555`	`555`	`let const_val = match rhs {`
`556`	`556`	`Operand::Constant(c) => {`
`557`		`- c.literal.try_eval_bits(self.tcx, self.param_env, lhs_ty)`
	`557`	`+ c.literal.try_eval_bits(self.tcx, self.param_env)`
`558`	`558`	`}`
`559`	`559`	`_ => None,`
`560`	`560`	`};`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {`
`100`	`100`	`expected: "constant pattern".to_string(),`
`101`	`101`	`});`
`102`	`102`	`};`
`103`		`- values.push(value.eval_bits(self.tcx, self.param_env, arm.pattern.ty));`
	`103`	`+ values.push(value.eval_bits(self.tcx, self.param_env));`
`104`	`104`	`targets.push(self.parse_block(arm.body)?);`
`105`	`105`	`}`
`106`	`106`
`@@ -301,7 +301,7 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {`
`301`	`301`	`\| ExprKind::NonHirLiteral { .. }`
`302`	`302`	`\| ExprKind::ConstBlock { .. } => Ok({`
`303`	`303`	`let value = as_constant_inner(expr, \|_\| None, self.tcx);`
`304`		`- value.literal.eval_bits(self.tcx, self.param_env, value.ty())`
	`304`	`+ value.literal.eval_bits(self.tcx, self.param_env)`
`305`	`305`	`}),`
`306`	`306`	`)`
`307`	`307`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1622,9 +1622,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`1622`	`1622`	`// may want to add cases based on the candidates that are`
`1623`	`1623`	`// available`
`1624`	`1624`	`match test.kind {`
`1625`		`- TestKind::SwitchInt { switch_ty, ref mut options } => {`
	`1625`	`+ TestKind::SwitchInt { switch_ty: _, ref mut options } => {`
`1626`	`1626`	`for candidate in candidates.iter() {`
`1627`		`- if !self.add_cases_to_switch(&match_place, candidate, switch_ty, options) {`
	`1627`	`+ if !self.add_cases_to_switch(&match_place, candidate, options) {`
`1628`	`1628`	`break;`
`1629`	`1629`	`}`
`1630`	`1630`	`}`
Original file line number	Diff line number	Diff line change
`@@ -131,15 +131,15 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {`
`131`	`131`	`if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = lo_expr`
`132`	`132`	`&& let rustc_ast::ast::LitKind::Int(val, _) = lit.node`
`133`	`133`	`{`
`134`		`- if lo.eval_bits(self.tcx, self.param_env, ty) != val {`
	`134`	`+ if lo.eval_bits(self.tcx, self.param_env) != val {`
`135`	`135`	`lower_overflow = true;`
`136`	`136`	`self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`	`if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = hi_expr`
`140`	`140`	`&& let rustc_ast::ast::LitKind::Int(val, _) = lit.node`
`141`	`141`	`{`
`142`		`- if hi.eval_bits(self.tcx, self.param_env, ty) != val {`
	`142`	`+ if hi.eval_bits(self.tcx, self.param_env) != val {`
`143`	`143`	`higher_overflow = true;`
`144`	`144`	`self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });`
`145`	`145`	`}`
`@@ -162,15 +162,15 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {`
`162`	`162`	`if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = lo_expr`
`163`	`163`	`&& let rustc_ast::ast::LitKind::Int(val, _) = lit.node`
`164`	`164`	`{`
`165`		`- if lo.eval_bits(self.tcx, self.param_env, ty) != val {`
	`165`	`+ if lo.eval_bits(self.tcx, self.param_env) != val {`
`166`	`166`	`lower_overflow = true;`
`167`	`167`	`self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`	`if let Some(hir::Expr { kind: hir::ExprKind::Lit(lit), .. }) = hi_expr`
`171`	`171`	`&& let rustc_ast::ast::LitKind::Int(val, _) = lit.node`
`172`	`172`	`{`
`173`		`- if hi.eval_bits(self.tcx, self.param_env, ty) != val {`
	`173`	`+ if hi.eval_bits(self.tcx, self.param_env) != val {`
`174`	`174`	`higher_overflow = true;`
`175`	`175`	`self.tcx.sess.emit_err(LiteralOutOfRange { span: lit.span, ty, max: max() });`
`176`	`176`	`}`
`@@ -865,8 +865,8 @@ pub(crate) fn compare_const_vals<'tcx>(`
`865`	`865`	`},`
`866`	`866`	`}`
`867`	`867`
`868`		`- let a = a.eval_bits(tcx, param_env, ty);`
`869`		`- let b = b.eval_bits(tcx, param_env, ty);`
	`868`	`+ let a = a.eval_bits(tcx, param_env);`
	`869`	`+ let b = b.eval_bits(tcx, param_env);`
`870`	`870`
`871`	`871`	`use rustc_apfloat::Float;`
`872`	`872`	`match *ty.kind() {`