update to use TyKind directly

Author: Ellen Arteca

src/shims/ffi_support.rs

@@ -1,7 +1,7 @@
 use libffi::{high::call as ffi, low::CodePtr};
 use std::ops::Deref;
 
-use rustc_middle::ty::{IntTy, Ty, TyKind, UintTy};
+use rustc_middle::ty::{self as ty, IntTy, Ty, UintTy};
 use rustc_span::Symbol;
 use rustc_target::abi::HasDataLayout;
 
@@ -14,44 +14,44 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     /// and convert it to a `CArg`.
     fn scalar_to_carg(
         k: ScalarMaybeUninit<Provenance>,
-        arg_type: &Ty<'tcx>,
+        arg_type: Ty<'tcx>,
         cx: &impl HasDataLayout,
     ) -> InterpResult<'tcx, CArg> {
         match arg_type.kind() {
             // If the primitive provided can be converted to a type matching the type pattern
             // then create a `CArg` of this primitive value with the corresponding `CArg` constructor.
             // the ints
-            TyKind::Int(IntTy::I8) => {
+            ty::Int(IntTy::I8) => {
                 return Ok(CArg::Int8(k.to_i8()?));
             }
-            TyKind::Int(IntTy::I16) => {
+            ty::Int(IntTy::I16) => {
                 return Ok(CArg::Int16(k.to_i16()?));
             }
-            TyKind::Int(IntTy::I32) => {
+            ty::Int(IntTy::I32) => {
                 return Ok(CArg::Int32(k.to_i32()?));
             }
-            TyKind::Int(IntTy::I64) => {
+            ty::Int(IntTy::I64) => {
                 return Ok(CArg::Int64(k.to_i64()?));
             }
-            TyKind::Int(IntTy::Isize) => {
+            ty::Int(IntTy::Isize) => {
                 // This will fail if host != target, but then the entire FFI thing probably won't work well
                 // in that situation.
                 return Ok(CArg::ISize(k.to_machine_isize(cx)?.try_into().unwrap()));
             }
             // the uints
-            TyKind::Uint(UintTy::U8) => {
+            ty::Uint(UintTy::U8) => {
                 return Ok(CArg::UInt8(k.to_u8()?));
             }
-            TyKind::Uint(UintTy::U16) => {
+            ty::Uint(UintTy::U16) => {
                 return Ok(CArg::UInt16(k.to_u16()?));
             }
-            TyKind::Uint(UintTy::U32) => {
+            ty::Uint(UintTy::U32) => {
                 return Ok(CArg::UInt32(k.to_u32()?));
             }
-            TyKind::Uint(UintTy::U64) => {
+            ty::Uint(UintTy::U64) => {
                 return Ok(CArg::UInt64(k.to_u64()?));
             }
-            TyKind::Uint(UintTy::Usize) => {
+            ty::Uint(UintTy::Usize) => {
                 // This will fail if host != target, but then the entire FFI thing probably won't work well
                 // in that situation.
                 return Ok(CArg::USize(k.to_machine_usize(cx)?.try_into().unwrap()));
@@ -85,55 +85,55 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             // primitive integer type, and then write this value out to the miri memory as an integer.
             match dest.layout.ty.kind() {
                 // ints
-                TyKind::Int(IntTy::I8) => {
+                ty::Int(IntTy::I8) => {
                     let x = ffi::call::<i8>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Int(IntTy::I16) => {
+                ty::Int(IntTy::I16) => {
                     let x = ffi::call::<i16>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Int(IntTy::I32) => {
+                ty::Int(IntTy::I32) => {
                     let x = ffi::call::<i32>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Int(IntTy::I64) => {
+                ty::Int(IntTy::I64) => {
                     let x = ffi::call::<i64>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Int(IntTy::Isize) => {
+                ty::Int(IntTy::Isize) => {
                     let x = ffi::call::<isize>(ptr, libffi_args.as_slice());
                     // `isize` doesn't `impl Into<i128>`, so convert manually.
                     // Convert to `i64` since this covers both 32- and 64-bit machines.
                     this.write_int(i64::try_from(x).unwrap(), dest)?;
                     return Ok(());
                 }
                 // uints
-                TyKind::Uint(UintTy::U8) => {
+                ty::Uint(UintTy::U8) => {
                     let x = ffi::call::<u8>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Uint(UintTy::U16) => {
+                ty::Uint(UintTy::U16) => {
                     let x = ffi::call::<u16>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Uint(UintTy::U32) => {
+                ty::Uint(UintTy::U32) => {
                     let x = ffi::call::<u32>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Uint(UintTy::U64) => {
+                ty::Uint(UintTy::U64) => {
                     let x = ffi::call::<u64>(ptr, libffi_args.as_slice());
                     this.write_int(x, dest)?;
                     return Ok(());
                 }
-                TyKind::Uint(UintTy::Usize) => {
+                ty::Uint(UintTy::Usize) => {
                     let x = ffi::call::<usize>(ptr, libffi_args.as_slice());
                     // `usize` doesn't `impl Into<i128>`, so convert manually.
                     // Convert to `u64` since this covers both 32- and 64-bit machines.
@@ -142,7 +142,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 }
                 // Functions with no declared return type (i.e., the default return)
                 // have the output_type `Tuple([])`.
-                TyKind::Tuple(t_list) =>
+                ty::Tuple(t_list) =>
                     if t_list.len() == 0 {
                         ffi::call::<()>(ptr, libffi_args.as_slice());
                         return Ok(());
@@ -226,7 +226,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         for cur_arg in args.iter() {
             libffi_args.push(Self::scalar_to_carg(
                 this.read_scalar(cur_arg)?,
-                &cur_arg.layout.ty,
+                cur_arg.layout.ty,
                 this,
             )?);
         }