Start moving over implementation details of Ty to rustc_type_ir,

remove `trait Ty`

Author: Jamesbarford

compiler/rustc_middle/src/query/keys.rs

@@ -6,6 +6,7 @@ use rustc_ast::tokenstream::TokenStream;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalModDefId};
 use rustc_hir::hir_id::OwnerId;
 use rustc_span::{DUMMY_SP, Ident, LocalExpnId, Span, Symbol};
+use rustc_type_ir::inherent::IntoKind;
 
 use crate::dep_graph::DepNodeIndex;
 use crate::infer::canonical::CanonicalQueryInput;
@@ -262,7 +263,7 @@ impl<'tcx> Key for Ty<'tcx> {
     }
 
     fn def_id_for_ty_in_cycle(&self) -> Option<DefId> {
-        match *self.kind() {
+        match self.kind() {
             ty::Adt(adt, _) => Some(adt.did()),
             ty::Coroutine(def_id, ..) => Some(def_id),
             _ => None,

compiler/rustc_middle/src/ty/adt.rs

@@ -224,6 +224,10 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         self.is_manually_drop()
     }
 
+    fn has_unsafe_fields(self) -> bool {
+        self.all_fields().any(|field| field.safety.is_unsafe())
+    }
+
     fn all_field_tys(
         self,
         tcx: TyCtxt<'tcx>,

compiler/rustc_middle/src/ty/context.rs

@@ -210,7 +210,7 @@ impl<'tcx> CtxtInterners<'tcx> {
     #[allow(rustc::usage_of_ty_tykind)]
     #[inline(never)]
     fn intern_ty(&self, kind: TyKind<'tcx>, sess: &Session, untracked: &Untracked) -> Ty<'tcx> {
-        Ty(Interned::new_unchecked(
+        Ty::from_interned(Interned::new_unchecked(
             self.type_
                 .intern(kind, |kind| {
                     let flags = ty::FlagComputation::<TyCtxt<'tcx>>::for_kind(&kind);

compiler/rustc_middle/src/ty/generic_args.rs

@@ -229,7 +229,7 @@ impl<'tcx> GenericArg<'tcx> {
                 REGION_TAG => GenericArgKind::Lifetime(ty::Region(Interned::new_unchecked(
                     ptr.cast::<ty::RegionKind<'tcx>>().as_ref(),
                 ))),
-                TYPE_TAG => GenericArgKind::Type(Ty(Interned::new_unchecked(
+                TYPE_TAG => GenericArgKind::Type(Ty::from_interned(Interned::new_unchecked(
                     ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(),
                 ))),
                 CONST_TAG => GenericArgKind::Const(ty::Const(Interned::new_unchecked(

compiler/rustc_middle/src/ty/mod.rs

@@ -60,6 +60,7 @@ pub use rustc_type_ir::fast_reject::DeepRejectCtxt;
     rustc::non_glob_import_of_type_ir_inherent
 )]
 use rustc_type_ir::inherent;
+use rustc_type_ir::inherent::IntoKind;
 pub use rustc_type_ir::relate::VarianceDiagInfo;
 pub use rustc_type_ir::solve::{CandidatePreferenceMode, SizedTraitKind};
 pub use rustc_type_ir::*;
@@ -104,7 +105,7 @@ pub use self::sty::{
     AliasTy, Article, Binder, BoundConst, BoundRegion, BoundRegionKind, BoundTy, BoundTyKind,
     BoundVariableKind, CanonicalPolyFnSig, CoroutineArgsExt, EarlyBinder, FnSig, InlineConstArgs,
     InlineConstArgsParts, ParamConst, ParamTy, PlaceholderConst, PlaceholderRegion,
-    PlaceholderType, PolyFnSig, TyKind, TypeAndMut, TypingMode, UpvarArgs,
+    PlaceholderType, PolyFnSig, Ty, TyKind, TypeAndMut, TypingMode, UpvarArgs,
 };
 pub use self::trait_def::TraitDef;
 pub use self::typeck_results::{
@@ -457,24 +458,6 @@ pub struct CReaderCacheKey {
 //#[rustc_pass_by_value]
 //pub struct Ty<'tcx>(Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>);
 
-impl<'tcx> rustc_type_ir::inherent::IntoKind for Ty<'tcx> {
-    type Kind = TyKind<'tcx>;
-
-    fn kind(self) -> TyKind<'tcx> {
-        *self.kind()
-    }
-}
-
-impl<'tcx> rustc_type_ir::Flags for Ty<'tcx> {
-    fn flags(&self) -> TypeFlags {
-        self.0.flags
-    }
-
-    fn outer_exclusive_binder(&self) -> DebruijnIndex {
-        self.0.outer_exclusive_binder
-    }
-}
-
 /// The crate outlives map is computed during typeck and contains the
 /// outlives of every item in the local crate. You should not use it
 /// directly, because to do so will make your pass dependent on the
@@ -594,7 +577,7 @@ impl<'tcx> Term<'tcx> {
         // and this is just going in the other direction.
         unsafe {
             match self.ptr.addr().get() & TAG_MASK {
-                TYPE_TAG => TermKind::Ty(Ty(Interned::new_unchecked(
+                TYPE_TAG => TermKind::Ty(Ty::from_interned(Interned::new_unchecked(
                     ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(),
                 ))),
                 CONST_TAG => TermKind::Const(ty::Const(Interned::new_unchecked(
@@ -630,7 +613,7 @@ impl<'tcx> Term<'tcx> {
 
     pub fn to_alias_term(self) -> Option<AliasTerm<'tcx>> {
         match self.kind() {
-            TermKind::Ty(ty) => match *ty.kind() {
+            TermKind::Ty(ty) => match ty.kind() {
                 ty::Alias(_kind, alias_ty) => Some(alias_ty.into()),
                 _ => None,
             },
@@ -2368,7 +2351,7 @@ fn typetree_from_ty_impl_inner<'tcx>(
     if ty.is_slice() {
         if let ty::Slice(element_ty) = ty.kind() {
             let element_tree =
-                typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false);
+                typetree_from_ty_impl_inner(tcx, element_ty, depth + 1, visited, false);
             return element_tree;
         }
     }

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

@@ -17,6 +17,7 @@ use rustc_hir::limit::Limit;
 use rustc_macros::{Lift, extension};
 use rustc_session::cstore::{ExternCrate, ExternCrateSource};
 use rustc_span::{Ident, RemapPathScopeComponents, Symbol, kw, sym};
+use rustc_type_ir::inherent::{GenericArgs as _, IntoKind as _};
 use rustc_type_ir::{Upcast as _, elaborate};
 use smallvec::SmallVec;
 
@@ -1156,7 +1157,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
 
                         write!(p, ")")?;
                         if let Some(ty) = return_ty.skip_binder().as_type() {
-                            if !ty.is_unit() {
+                            if !matches!(ty.kind(), ty::Tuple(tys) if tys.is_empty()) {
                                 write!(p, " -> ")?;
                                 return_ty.print(p)?;
                             }
@@ -1175,7 +1176,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                         trait_ref: ty::TraitRef::new(
                             tcx,
                             trait_def_id,
-                            [self_ty, Ty::new_tup(tcx, args)],
+                            [self_ty, ty::Ty::new_tup(tcx, args)],
                         ),
                     }),
                     FxIndexMap::default(),
@@ -1520,7 +1521,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             write!(self, "...")?;
         }
         write!(self, ")")?;
-        if !output.is_unit() {
+        if !matches!(output.kind(), ty::Tuple(tys) if tys.is_empty()) {
             write!(self, " -> ")?;
             output.print(self)?;
         }
@@ -2029,7 +2030,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             }
             write!(p, ")")?;
 
-            if !sig.output().is_unit() {
+            if !matches!(sig.output().kind(), ty::Tuple(tys) if tys.is_empty()) {
                 write!(p, " -> ")?;
                 sig.output().print(p)?;
             }

compiler/rustc_middle/src/ty/relate.rs

@@ -3,21 +3,10 @@ use std::iter;
 pub use rustc_type_ir::relate::*;
 
 use crate::ty::error::{ExpectedFound, TypeError};
-use crate::ty::{self as ty, Ty, TyCtxt};
+use crate::ty::{self as ty, TyCtxt};
 
 pub type RelateResult<'tcx, T> = rustc_type_ir::relate::RelateResult<TyCtxt<'tcx>, T>;
 
-impl<'tcx> Relate<TyCtxt<'tcx>> for Ty<'tcx> {
-    #[inline]
-    fn relate<R: TypeRelation<TyCtxt<'tcx>>>(
-        relation: &mut R,
-        a: Ty<'tcx>,
-        b: Ty<'tcx>,
-    ) -> RelateResult<'tcx, Ty<'tcx>> {
-        relation.tys(a, b)
-    }
-}
-
 impl<'tcx> Relate<TyCtxt<'tcx>> for ty::Pattern<'tcx> {
     #[inline]
     fn relate<R: TypeRelation<TyCtxt<'tcx>>>(

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -327,165 +327,6 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Pattern<'tcx> {
     }
 }
 
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        folder.try_fold_ty(self)
-    }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        folder.fold_ty(self)
-    }
-}
-
-impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
-    fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
-        visitor.visit_ty(*self)
-    }
-}
-
-impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
-    fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        let kind = match *self.kind() {
-            ty::RawPtr(ty, mutbl) => ty::RawPtr(ty.try_fold_with(folder)?, mutbl),
-            ty::Array(typ, sz) => ty::Array(typ.try_fold_with(folder)?, sz.try_fold_with(folder)?),
-            ty::Slice(typ) => ty::Slice(typ.try_fold_with(folder)?),
-            ty::Adt(tid, args) => ty::Adt(tid, args.try_fold_with(folder)?),
-            ty::Dynamic(trait_ty, region) => {
-                ty::Dynamic(trait_ty.try_fold_with(folder)?, region.try_fold_with(folder)?)
-            }
-            ty::Tuple(ts) => ty::Tuple(ts.try_fold_with(folder)?),
-            ty::FnDef(def_id, args) => ty::FnDef(def_id, args.try_fold_with(folder)?),
-            ty::FnPtr(sig_tys, hdr) => ty::FnPtr(sig_tys.try_fold_with(folder)?, hdr),
-            ty::UnsafeBinder(f) => ty::UnsafeBinder(f.try_fold_with(folder)?),
-            ty::Ref(r, ty, mutbl) => {
-                ty::Ref(r.try_fold_with(folder)?, ty.try_fold_with(folder)?, mutbl)
-            }
-            ty::Coroutine(did, args) => ty::Coroutine(did, args.try_fold_with(folder)?),
-            ty::CoroutineWitness(did, args) => {
-                ty::CoroutineWitness(did, args.try_fold_with(folder)?)
-            }
-            ty::Closure(did, args) => ty::Closure(did, args.try_fold_with(folder)?),
-            ty::CoroutineClosure(did, args) => {
-                ty::CoroutineClosure(did, args.try_fold_with(folder)?)
-            }
-            ty::Alias(kind, data) => ty::Alias(kind, data.try_fold_with(folder)?),
-            ty::Pat(ty, pat) => ty::Pat(ty.try_fold_with(folder)?, pat.try_fold_with(folder)?),
-
-            ty::Bool
-            | ty::Char
-            | ty::Str
-            | ty::Int(_)
-            | ty::Uint(_)
-            | ty::Float(_)
-            | ty::Error(_)
-            | ty::Infer(_)
-            | ty::Param(..)
-            | ty::Bound(..)
-            | ty::Placeholder(..)
-            | ty::Never
-            | ty::Foreign(..) => return Ok(self),
-        };
-
-        Ok(if *self.kind() == kind { self } else { folder.cx().mk_ty_from_kind(kind) })
-    }
-
-    fn super_fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        let kind = match *self.kind() {
-            ty::RawPtr(ty, mutbl) => ty::RawPtr(ty.fold_with(folder), mutbl),
-            ty::Array(typ, sz) => ty::Array(typ.fold_with(folder), sz.fold_with(folder)),
-            ty::Slice(typ) => ty::Slice(typ.fold_with(folder)),
-            ty::Adt(tid, args) => ty::Adt(tid, args.fold_with(folder)),
-            ty::Dynamic(trait_ty, region) => {
-                ty::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder))
-            }
-            ty::Tuple(ts) => ty::Tuple(ts.fold_with(folder)),
-            ty::FnDef(def_id, args) => ty::FnDef(def_id, args.fold_with(folder)),
-            ty::FnPtr(sig_tys, hdr) => ty::FnPtr(sig_tys.fold_with(folder), hdr),
-            ty::UnsafeBinder(f) => ty::UnsafeBinder(f.fold_with(folder)),
-            ty::Ref(r, ty, mutbl) => ty::Ref(r.fold_with(folder), ty.fold_with(folder), mutbl),
-            ty::Coroutine(did, args) => ty::Coroutine(did, args.fold_with(folder)),
-            ty::CoroutineWitness(did, args) => ty::CoroutineWitness(did, args.fold_with(folder)),
-            ty::Closure(did, args) => ty::Closure(did, args.fold_with(folder)),
-            ty::CoroutineClosure(did, args) => ty::CoroutineClosure(did, args.fold_with(folder)),
-            ty::Alias(kind, data) => ty::Alias(kind, data.fold_with(folder)),
-            ty::Pat(ty, pat) => ty::Pat(ty.fold_with(folder), pat.fold_with(folder)),
-
-            ty::Bool
-            | ty::Char
-            | ty::Str
-            | ty::Int(_)
-            | ty::Uint(_)
-            | ty::Float(_)
-            | ty::Error(_)
-            | ty::Infer(_)
-            | ty::Param(..)
-            | ty::Bound(..)
-            | ty::Placeholder(..)
-            | ty::Never
-            | ty::Foreign(..) => return self,
-        };
-
-        if *self.kind() == kind { self } else { folder.cx().mk_ty_from_kind(kind) }
-    }
-}
-
-impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
-    fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
-        match self.kind() {
-            ty::RawPtr(ty, _mutbl) => ty.visit_with(visitor),
-            ty::Array(typ, sz) => {
-                try_visit!(typ.visit_with(visitor));
-                sz.visit_with(visitor)
-            }
-            ty::Slice(typ) => typ.visit_with(visitor),
-            ty::Adt(_, args) => args.visit_with(visitor),
-            ty::Dynamic(trait_ty, reg) => {
-                try_visit!(trait_ty.visit_with(visitor));
-                reg.visit_with(visitor)
-            }
-            ty::Tuple(ts) => ts.visit_with(visitor),
-            ty::FnDef(_, args) => args.visit_with(visitor),
-            ty::FnPtr(sig_tys, _) => sig_tys.visit_with(visitor),
-            ty::UnsafeBinder(f) => f.visit_with(visitor),
-            ty::Ref(r, ty, _) => {
-                try_visit!(r.visit_with(visitor));
-                ty.visit_with(visitor)
-            }
-            ty::Coroutine(_did, args) => args.visit_with(visitor),
-            ty::CoroutineWitness(_did, args) => args.visit_with(visitor),
-            ty::Closure(_did, args) => args.visit_with(visitor),
-            ty::CoroutineClosure(_did, args) => args.visit_with(visitor),
-            ty::Alias(_, data) => data.visit_with(visitor),
-
-            ty::Pat(ty, pat) => {
-                try_visit!(ty.visit_with(visitor));
-                pat.visit_with(visitor)
-            }
-
-            ty::Error(guar) => guar.visit_with(visitor),
-
-            ty::Bool
-            | ty::Char
-            | ty::Str
-            | ty::Int(_)
-            | ty::Uint(_)
-            | ty::Float(_)
-            | ty::Infer(_)
-            | ty::Bound(..)
-            | ty::Placeholder(..)
-            | ty::Param(..)
-            | ty::Never
-            | ty::Foreign(..) => V::Result::output(),
-        }
-    }
-}
-
 impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ty::Region<'tcx> {
     fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
         self,