Moved over methods to rustc_type_ir and added helper functions to

interner.

Author: Jamesbarford

compiler/rustc_middle/src/mir/consts.rs

@@ -94,10 +94,6 @@ impl ConstValue {
         self.try_to_scalar_int()?.try_into().ok()
     }
 
-    pub fn try_to_target_usize(&self, tcx: TyCtxt<'_>) -> Option<u64> {
-        Some(self.try_to_scalar_int()?.to_target_usize(tcx))
-    }
-
     pub fn try_to_bits_for_ty<'tcx>(
         &self,
         tcx: TyCtxt<'tcx>,

compiler/rustc_middle/src/ty/adt.rs

@@ -211,6 +211,22 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         self.is_struct()
     }
 
+    fn is_box(self) -> bool {
+        self.is_box()
+    }
+
+    fn is_pin(self) -> bool {
+        self.is_pin()
+    }
+
+    fn is_enum(self) -> bool {
+        self.is_enum()
+    }
+
+    fn is_union(self) -> bool {
+        self.is_union()
+    }
+
     fn struct_tail_ty(self, interner: TyCtxt<'tcx>) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
         Some(interner.type_of(self.non_enum_variant().tail_opt()?.did))
     }
@@ -254,6 +270,24 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
             hir::Constness::NotConst => AdtDestructorKind::NotConst,
         })
     }
+
+    /// Asserts this is a struct or union and returns its unique variant.
+    fn non_enum_variant(self) -> &'tcx VariantDef {
+        assert!(self.is_struct() || self.is_union());
+        self.variant(FIRST_VARIANT)
+    }
+
+    fn repr_is_simd(self) -> bool {
+        self.0.0.repr.simd()
+    }
+
+    fn scalable_element_cnt(self) -> Option<u16> {
+        if Some(ScalableElt::ElementCount(element_count)) = self.repr().scalable {
+            Some(element_count)
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, HashStable, TyEncodable, TyDecodable)]
@@ -458,12 +492,6 @@ impl<'tcx> AdtDef<'tcx> {
         self.destructor(tcx).is_some()
     }
 
-    /// Asserts this is a struct or union and returns its unique variant.
-    pub fn non_enum_variant(self) -> &'tcx VariantDef {
-        assert!(self.is_struct() || self.is_union());
-        self.variant(FIRST_VARIANT)
-    }
-
     #[inline]
     pub fn predicates(self, tcx: TyCtxt<'tcx>) -> GenericPredicates<'tcx> {
         tcx.predicates_of(self.did())

compiler/rustc_middle/src/ty/consts.rs

@@ -213,6 +213,10 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
     fn new_error(interner: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Self {
         Const::new_error(interner, guar)
     }
+
+    fn try_to_target_usize(&self, tcx: TyCtxt<'tcx>) -> Option<u64> {
+        Some(self.try_to_scalar_int()?.to_target_usize(tcx))
+    }
 }
 
 impl<'tcx> Const<'tcx> {

compiler/rustc_middle/src/ty/context.rs

@@ -1100,10 +1100,6 @@ impl<'tcx> TyCtxt<'tcx> {
         self.coroutine_kind(def_id).is_some()
     }
 
-    pub fn is_async_drop_in_place_coroutine(self, def_id: DefId) -> bool {
-        self.is_lang_item(self.parent(def_id), LangItem::AsyncDropInPlace)
-    }
-
     pub fn type_const_span(self, def_id: DefId) -> Option<Span> {
         if !self.is_type_const(def_id) {
             return None;

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -1,8 +1,9 @@
 //! Implementation of [`rustc_type_ir::Interner`] for [`TyCtxt`].
 
 use std::fmt;
+use std::ops::Range;
 
-use rustc_abi::ExternAbi;
+use rustc_abi::{ExternAbi, VariantIdx};
 use rustc_data_structures::debug_assert_matches;
 use rustc_data_structures::intern::Interned;
 use rustc_errors::ErrorGuaranteed;
@@ -22,8 +23,8 @@ use crate::traits::solve::{
     self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, QueryResult, inspect,
 };
 use crate::ty::{
-    self, Clause, Const, List, ParamTy, Pattern, PolyExistentialPredicate, Predicate, Region, Ty,
-    TyCtxt,
+    self, AdtDef, Clause, Const, List, ParamTy, Pattern, PolyExistentialPredicate, Predicate,
+    Region, Ty, TyCtxt, VariantDef,
 };
 
 #[allow(rustc::usage_of_ty_tykind)]
@@ -41,11 +42,14 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type CoroutineClosureId = DefId;
     type CoroutineId = DefId;
     type AdtId = DefId;
+    type AdtDef = AdtDef;
+    type VariantDef = VariantDef;
     type ImplId = DefId;
     type UnevaluatedConstId = DefId;
     type Span = Span;
     type Interned<T: Copy + Clone + std::fmt::Debug + std::hash::Hash + Eq + PartialEq> =
         Interned<'tcx, T>;
+    type VariantIdx = VariantIdx;
 
     type GenericArgs = ty::GenericArgsRef<'tcx>;
 
@@ -738,6 +742,23 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             bug!("item_name: no name for {:?}", self.def_path(id));
         })
     }
+
+    fn u8_type(self) -> Ty<'tcx> {
+        self.types.u8
+    }
+
+    fn is_async_drop_in_place_coroutine(self, def_id: DefId) -> bool {
+        self.is_lang_item(self.parent(def_id), LangItem::AsyncDropInPlace)
+    }
+
+    #[inline]
+    fn coroutine_variant_range(
+        self,
+        def_id: DefId,
+        coroutine_args: ty::CoroutineArgs<Self>,
+    ) -> Range<VariantIdx> {
+        self.coroutine_variant_range(def_id, coroutine_args)
+    }
 }
 
 /// Defines trivial conversion functions between the main [`LangItem`] enum,

compiler/rustc_middle/src/ty/mod.rs

@@ -1238,6 +1238,16 @@ impl VariantDef {
     }
 }
 
+impl<'tcx> rustc_type_ir::inherent::VariantDef for VariantDef {
+    fn field_zero_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+        self.fields[FieldIdx::ZERO].ty(tcx, args)
+    }
+
+    fn fields_len(self) -> usize {
+        self.fields.len()
+    }
+}
+
 impl PartialEq for VariantDef {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -2148,6 +2158,18 @@ impl<'tcx> TyCtxt<'tcx> {
 
         !self.associated_types_for_impl_traits_in_associated_fn(trait_item_def_id).is_empty()
     }
+
+    /// The valid variant indices of this coroutine.
+    #[inline]
+    pub fn coroutine_variant_range(
+        self,
+        def_id: DefId,
+        coroutine_args: ty::CoroutineArgs<Self>,
+    ) -> Range<VariantIdx> {
+        // FIXME requires optimized MIR
+        rustc_abi::FIRST_VARIANT
+            ..self.coroutine_layout(def_id, coroutine_args).unwrap().variant_fields.next_index()
+    }
 }
 
 pub fn provide(providers: &mut Providers) {

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1157,7 +1157,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
 
                         write!(p, ")")?;
                         if let Some(ty) = return_ty.skip_binder().as_type() {
-                            if !matches!(ty.kind(), ty::Tuple(tys) if tys.is_empty()) {
+                            if !matches!(ty.is_unit()) {
                                 write!(p, " -> ")?;
                                 return_ty.print(p)?;
                             }