PR-Feedback; remove manual Lift implementations

Author: Jamesbarford

compiler/rustc_middle/src/ty/context.rs

@@ -1779,6 +1779,7 @@ macro_rules! nop_list_lift {
 
 nop_lift! { type_; Ty<'a> => Ty<'tcx> }
 nop_lift! { const_; Const<'a> => Const<'tcx> }
+nop_lift! { region; Region<'a> => Region<'tcx> }
 nop_lift! { pat; Pattern<'a> => Pattern<'tcx> }
 nop_lift! { const_allocation; ConstAllocation<'a> => ConstAllocation<'tcx> }
 nop_lift! { predicate; Predicate<'a> => Predicate<'tcx> }

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -192,16 +192,11 @@ TrivialLiftImpls! {
     crate::mir::Promoted,
     crate::mir::interpret::AllocId,
     crate::mir::interpret::Scalar,
-    crate::ty::EarlyParamRegion,
-    crate::ty::LateParamRegion,
-    crate::ty::LateParamRegionKind,
     crate::ty::ParamConst,
     rustc_abi::ExternAbi,
     rustc_abi::Size,
     rustc_hir::Safety,
     rustc_middle::mir::ConstValue,
-    rustc_span::ErrorGuaranteed,
-    rustc_span::Symbol,
     rustc_type_ir::BoundConstness,
     rustc_type_ir::PredicatePolarity,
     // tidy-alphabetical-end

compiler/rustc_type_ir/src/binder.rs

@@ -1121,17 +1121,6 @@ pub struct BoundRegion<I: Interner> {
     pub kind: BoundRegionKind<I>,
 }
 
-impl<I: Interner, U: Interner> Lift<U> for BoundRegion<I>
-where
-    BoundRegionKind<I>: Lift<U, Lifted = BoundRegionKind<U>>,
-{
-    type Lifted = BoundRegion<U>;
-
-    fn lift_to_interner(self, interner: U) -> Option<Self::Lifted> {
-        Some(BoundRegion { var: self.var, kind: self.kind.lift_to_interner(interner)? })
-    }
-}
-
 impl<I: Interner> core::fmt::Debug for BoundRegion<I> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self.kind {

compiler/rustc_type_ir/src/region_kind.rs

@@ -8,7 +8,6 @@ use rustc_macros::{Decodable_NoContext, Encodable_NoContext};
 use rustc_type_ir_macros::GenericTypeVisitable;
 
 use self::RegionKind::*;
-use crate::lift::Lift;
 use crate::{BoundRegion, BoundVarIndexKind, Interner, PlaceholderRegion};
 
 rustc_index::newtype_index! {
@@ -188,33 +187,6 @@ pub enum RegionKind<I: Interner> {
 
 impl<I: Interner> Eq for RegionKind<I> {}
 
-impl<I: Interner, U: Interner> Lift<U> for RegionKind<I>
-where
-    I::EarlyParamRegion: Lift<U, Lifted = U::EarlyParamRegion>,
-    BoundRegion<I>: Lift<U, Lifted = BoundRegion<U>>,
-    I::LateParamRegion: Lift<U, Lifted = U::LateParamRegion>,
-    PlaceholderRegion<I>: Lift<U, Lifted = PlaceholderRegion<U>>,
-    I::ErrorGuaranteed: Lift<U, Lifted = U::ErrorGuaranteed>,
-{
-    type Lifted = RegionKind<U>;
-
-    fn lift_to_interner(self, interner: U) -> Option<Self::Lifted> {
-        Some(match self {
-            ReEarlyParam(region) => ReEarlyParam(region.lift_to_interner(interner)?),
-            ReBound(index, region) => {
-                ReBound(index.lift_to_interner(interner)?, region.lift_to_interner(interner)?)
-            }
-            ReLateParam(region) => ReLateParam(region.lift_to_interner(interner)?),
-            ReStatic => ReStatic,
-            // Inference vars are local to the originating inference context.
-            ReVar(_) => return None,
-            RePlaceholder(placeholder) => RePlaceholder(placeholder.lift_to_interner(interner)?),
-            ReErased => ReErased,
-            ReError(reported) => ReError(reported.lift_to_interner(interner)?),
-        })
-    }
-}
-
 impl<I: Interner> fmt::Debug for RegionKind<I> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

compiler/rustc_type_ir/src/sty/mod.rs

@@ -9,7 +9,6 @@ use rustc_serialize::{Decodable, Encodable};
 use tracing::debug;
 
 use crate::inherent::*;
-use crate::lift::Lift;
 use crate::relate::{Relate, RelateResult, TypeRelation};
 use crate::{
     BoundRegion, BoundRegionKind, BoundVar, BoundVarIndexKind, DebruijnIndex, FallibleTypeFolder,
@@ -188,17 +187,6 @@ impl<I: Interner> TypeFoldable<I> for Region<I> {
     }
 }
 
-impl<I: Interner, U: Interner> Lift<U> for Region<I>
-where
-    RegionKind<I>: Lift<U, Lifted = RegionKind<U>>,
-{
-    type Lifted = Region<U>;
-
-    fn lift_to_interner(self, interner: U) -> Option<Self::Lifted> {
-        Some(interner.intern_region(self.kind().lift_to_interner(interner)?))
-    }
-}
-
 #[cfg(feature = "nightly")]
 impl<I: Interner, E: rustc_serialize::Encoder> Encodable<E> for Region<I>
 where