get rid of visit_constant in thir visitor

compiler/rustc_middle/src/thir/visit.rs

 use super::{
     Arm, Block, Expr, ExprKind, Guard, InlineAsmOperand, Pat, PatKind, Stmt, StmtKind, Thir,
 };
-use crate::mir::ConstantKind;
 
 pub trait Visitor<'a, 'tcx: 'a>: Sized {
     fn thir(&self) -> &'a Thir<'tcx>;
@@ -26,7 +25,14 @@ fn visit_pat(&mut self, pat: &Pat<'tcx>) {
         walk_pat(self, pat);
     }
 
-    fn visit_constant(&mut self, _constant: ConstantKind<'tcx>) {}
+    // Note: We don't have visitors for `ty::Const` and `mir::ConstantKind`
+    // (even though these types occur in THIR) for consistency and to reduce confusion,
+    // since the lazy creation of constants during thir construction causes most
+    // 'constants' to not be of type `ty::Const` or `mir::ConstantKind` at that
+    // stage (they are mostly still identified by `DefId` or `hir::Lit`, see
+    // the variants `Literal`, `NonHirLiteral` and `NamedConst` in `thir::ExprKind`).
+    // You have to manually visit `ty::Const` and `mir::ConstantKind` through the
+    // other `visit*` functions.
 }
 
 pub fn walk_expr<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, expr: &Expr<'tcx>) {

compiler/rustc_middle/src/ty/util.rs

@@ -662,8 +662,8 @@ fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
 impl<'tcx> Ty<'tcx> {
     /// Returns the maximum value for the given numeric type (including `char`s)
     /// or returns `None` if the type is not numeric.
-    pub fn numeric_max_val(self, tcx: TyCtxt<'tcx>) -> Option<u128> {
-        match self.kind() {
+    pub fn numeric_max_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>> {
+        let val = match self.kind() {
             ty::Int(_) | ty::Uint(_) => {
                 let (size, signed) = int_size_and_signed(tcx, self);
                 let val =
@@ -676,13 +676,14 @@ pub fn numeric_max_val(self, tcx: TyCtxt<'tcx>) -> Option<u128> {
                 ty::FloatTy::F64 => rustc_apfloat::ieee::Double::INFINITY.to_bits(),
             }),
             _ => None,
-        }
+        };
+        val.map(|v| Const::from_bits(tcx, v, ty::ParamEnv::empty().and(self)))
     }
 
     /// Returns the minimum value for the given numeric type (including `char`s)
     /// or returns `None` if the type is not numeric.
-    pub fn numeric_min_val(self, tcx: TyCtxt<'tcx>) -> Option<u128> {
-        match self.kind() {
+    pub fn numeric_min_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>> {
+        let val = match self.kind() {
             ty::Int(_) | ty::Uint(_) => {
                 let (size, signed) = int_size_and_signed(tcx, self);
                 let val = if signed { size.truncate(size.signed_int_min() as u128) } else { 0 };
@@ -694,7 +695,8 @@ pub fn numeric_min_val(self, tcx: TyCtxt<'tcx>) -> Option<u128> {
                 ty::FloatTy::F64 => (-::rustc_apfloat::ieee::Double::INFINITY).to_bits(),
             }),
             _ => None,
-        }
+        };
+        val.map(|v| Const::from_bits(tcx, v, ty::ParamEnv::empty().and(self)))
     }
 
     /// Checks whether values of this type `T` are *moved* or *copied*

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

@@ -183,12 +183,10 @@ fn normalize_range_pattern_ends(
                 Some((*lo, *hi))
             }
             (Some(PatKind::Constant { value: lo }), None) => {
-                let hi = ty.numeric_max_val(self.tcx)?;
-                Some((*lo, ty::Const::from_bits(self.tcx, hi, ty::ParamEnv::empty().and(ty))))
+                Some((*lo, ty.numeric_max_val(self.tcx)?))
             }
             (None, Some(PatKind::Constant { value: hi })) => {
-                let lo = ty.numeric_min_val(self.tcx)?;
-                Some((ty::Const::from_bits(self.tcx, lo, ty::ParamEnv::empty().and(ty)), *hi))
+                Some((ty.numeric_min_val(self.tcx)?, *hi))
             }
             _ => None,
         }

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -376,10 +376,6 @@ fn visit_pat(&mut self, pat: &thir::Pat<'tcx>) {
                     visit::walk_pat(self, pat);
                 }
             }
-
-            fn visit_constant(&mut self, ct: mir::ConstantKind<'tcx>) {
-                self.is_poly |= ct.has_param_types_or_consts();
-            }
         }
 
         let mut is_poly_vis = IsThirPolymorphic { is_poly: false, thir: body };

src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs

-use clippy_utils::consts::{constant, constant_full_int, FullInt};
+use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
 use clippy_utils::diagnostics::span_lint_and_note;
 use core::cmp::Ordering;
 use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
@@ -32,15 +32,16 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
         .filter_map(|arm| {
             if let Arm { pat, guard: None, .. } = *arm {
                 if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
-                    let lhs_val = match lhs {
-                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0.int_value(cx, ty)?,
-                        None => FullInt::U(ty.numeric_min_val(cx.tcx)?),
+                    let lhs_const = match lhs {
+                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
+                        None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
                     };
-                    let rhs_val = match rhs {
-                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0.int_value(cx, ty)?,
-                        None => FullInt::U(ty.numeric_max_val(cx.tcx)?),
+                    let rhs_const = match rhs {
+                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
+                        None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
                     };
-
+                    let lhs_val = lhs_const.int_value(cx, ty)?;
+                    let rhs_val = rhs_const.int_value(cx, ty)?;
                     let rhs_bound = match range_end {
                         RangeEnd::Included => EndBound::Included(rhs_val),
                         RangeEnd::Excluded => EndBound::Excluded(rhs_val),