Stop relying on rustc_type_ir in non-type-system crates

compiler/rustc_const_eval/Cargo.toml

@@ -23,6 +23,5 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-rustc_type_ir = { path = "../rustc_type_ir" }
 tracing = "0.1"
 # tidy-alphabetical-end

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -9,7 +9,6 @@ use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{IntegerExt, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, FloatTy, Ty};
 use rustc_middle::{bug, span_bug};
-use rustc_type_ir::TyKind::*;
 use tracing::trace;
 
 use super::util::ensure_monomorphic_enough;
@@ -182,9 +181,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         src: &ImmTy<'tcx, M::Provenance>,
         cast_to: TyAndLayout<'tcx>,
     ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
-        use rustc_type_ir::TyKind::*;
-
-        let Float(fty) = src.layout.ty.kind() else {
+        let ty::Float(fty) = src.layout.ty.kind() else {
             bug!("FloatToFloat/FloatToInt cast: source type {} is not a float type", src.layout.ty)
         };
         let val = match fty {
@@ -277,19 +274,19 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let signed = src_layout.backend_repr.is_signed(); // Also asserts that abi is `Scalar`.
 
         let v = match src_layout.ty.kind() {
-            Uint(_) | RawPtr(..) | FnPtr(..) => scalar.to_uint(src_layout.size)?,
-            Int(_) => scalar.to_int(src_layout.size)? as u128, // we will cast back to `i128` below if the sign matters
-            Bool => scalar.to_bool()?.into(),
-            Char => scalar.to_char()?.into(),
+            ty::Uint(_) | ty::RawPtr(..) | ty::FnPtr(..) => scalar.to_uint(src_layout.size)?,
+            ty::Int(_) => scalar.to_int(src_layout.size)? as u128, // we will cast back to `i128` below if the sign matters
+            ty::Bool => scalar.to_bool()?.into(),
+            ty::Char => scalar.to_char()?.into(),
             _ => span_bug!(self.cur_span(), "invalid int-like cast from {}", src_layout.ty),
         };
 
         interp_ok(match *cast_ty.kind() {
             // int -> int
-            Int(_) | Uint(_) => {
+            ty::Int(_) | ty::Uint(_) => {
                 let size = match *cast_ty.kind() {
-                    Int(t) => Integer::from_int_ty(self, t).size(),
-                    Uint(t) => Integer::from_uint_ty(self, t).size(),
+                    ty::Int(t) => Integer::from_int_ty(self, t).size(),
+                    ty::Uint(t) => Integer::from_uint_ty(self, t).size(),
                     _ => bug!(),
                 };
                 let v = size.truncate(v);
@@ -297,7 +294,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
 
             // signed int -> float
-            Float(fty) if signed => {
+            ty::Float(fty) if signed => {
                 let v = v as i128;
                 match fty {
                     FloatTy::F16 => Scalar::from_f16(Half::from_i128(v).value),
@@ -307,7 +304,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
             }
             // unsigned int -> float
-            Float(fty) => match fty {
+            ty::Float(fty) => match fty {
                 FloatTy::F16 => Scalar::from_f16(Half::from_u128(v).value),
                 FloatTy::F32 => Scalar::from_f32(Single::from_u128(v).value),
                 FloatTy::F64 => Scalar::from_f64(Double::from_u128(v).value),
@@ -315,7 +312,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             },
 
             // u8 -> char
-            Char => Scalar::from_u32(u8::try_from(v).unwrap().into()),
+            ty::Char => Scalar::from_u32(u8::try_from(v).unwrap().into()),
 
             // Casts to bool are not permitted by rustc, no need to handle them here.
             _ => span_bug!(self.cur_span(), "invalid int to {} cast", cast_ty),
@@ -332,11 +329,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             + FloatConvert<Double>
             + FloatConvert<Quad>,
     {
-        use rustc_type_ir::TyKind::*;
-
         match *dest_ty.kind() {
             // float -> uint
-            Uint(t) => {
+            ty::Uint(t) => {
                 let size = Integer::from_uint_ty(self, t).size();
                 // `to_u128` is a saturating cast, which is what we need
                 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
@@ -345,7 +340,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 Scalar::from_uint(v, size)
             }
             // float -> int
-            Int(t) => {
+            ty::Int(t) => {
                 let size = Integer::from_int_ty(self, t).size();
                 // `to_i128` is a saturating cast, which is what we need
                 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
@@ -353,7 +348,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 Scalar::from_int(v, size)
             }
             // float -> float
-            Float(fty) => match fty {
+            ty::Float(fty) => match fty {
                 FloatTy::F16 => {
                     Scalar::from_f16(self.adjust_nan(f.convert(&mut false).value, &[f]))
                 }