Trait rustc_middle::ty::context::Lift

pub trait Lift<'tcx>: Debug {
    type Lifted: Debug + 'tcx;
    fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>;
}

A trait implemented for all X<'a> types that can be safely and efficiently converted to X<'tcx> as long as they are part of the provided TyCtxt<'tcx>. This can be done, for example, for Ty<'tcx> or SubstsRef<'tcx> by looking them up in their respective interners.

However, this is still not the best implementation as it does need to compare the components, even for interned values. It would be more efficient if TypedArena provided a way to determine whether the address is in the allocated range.

None is returned if the value or one of the components is not part of the provided context. For Ty, None can be returned if either the type interner doesn’t contain the TyKind key or if the address of the interned pointer differs. The latter case is possible if a primitive type, e.g., () or u8, was interned in a different context.

Associated Types

type Lifted: Debug + 'tcx

Required methods

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

Implementations on Foreign Types

impl<'tcx> Lift<'tcx> for Constness

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ()

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for bool

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for usize

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for VariantIdx

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for u32

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for u64

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for String

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for InlineAsmOptions

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for InlineAsmTemplatePiece

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for NodeId

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Symbol

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Res

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for DefId

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for LocalDefId

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for HirId

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for LlvmInlineAsmInner

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for MatchSource

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Unsafety

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for InlineAsmRegOrRegClass

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Abi

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Span

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx, A: Lift<'tcx>, B: Lift<'tcx>> Lift<'tcx> for (A, B)

type Lifted = (A::Lifted, B::Lifted)

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, A: Lift<'tcx>, B: Lift<'tcx>, C: Lift<'tcx>> Lift<'tcx> for (A, B, C)

type Lifted = (A::Lifted, B::Lifted, C::Lifted)

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for Option<T>

type Lifted = Option<T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx>, E: Lift<'tcx>> Lift<'tcx> for Result<T, E>

type Lifted = Result<T::Lifted, E::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for Box<T>

type Lifted = Box<T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx> + Clone> Lift<'tcx> for Rc<T>

type Lifted = Rc<T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx> + Clone> Lift<'tcx> for Arc<T>

type Lifted = Arc<T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for Vec<T>

type Lifted = Vec<T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, I: Idx, T: Lift<'tcx>> Lift<'tcx> for IndexVec<I, T>

type Lifted = IndexVec<I, T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

Implementors

impl<'__lifted, N> Lift<'__lifted> for ImplSourceAutoImplData<N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceAutoImplData<N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceAutoImplData<N::Lifted>>

impl<'__lifted, N> Lift<'__lifted> for ImplSourceBuiltinData<N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceBuiltinData<N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceBuiltinData<N::Lifted>>

impl<'__lifted, T> Lift<'__lifted> for Normalize<T> where
    T: Lift<'__lifted>, 

type Lifted = Normalize<T::Lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<Normalize<T::Lifted>>

impl<'__lifted, T> Lift<'__lifted> for WithOptConstParam<T> where
    T: Lift<'__lifted>, 

type Lifted = WithOptConstParam<T::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<WithOptConstParam<T::Lifted>>

impl<'a, 'tcx> Lift<'tcx> for &'a Allocation

type Lifted = &'tcx Allocation

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a Const<'a>

type Lifted = &'tcx Const<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<BoundVariableKind>

type Lifted = &'tcx List<BoundVariableKind>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<CanonicalVarInfo<'a>>

type Lifted = &'tcx List<CanonicalVarInfo<'tcx>>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<Predicate<'a>>

type Lifted = &'tcx List<Predicate<'tcx>>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<Binder<'a, ExistentialPredicate<'a>>>

type Lifted = &'tcx List<Binder<'tcx, ExistentialPredicate<'tcx>>>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<GenericArg<'a>>

type Lifted = &'tcx List<GenericArg<'tcx>>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<ProjectionKind>

type Lifted = &'tcx List<ProjectionKind>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a List<Ty<'a>>

type Lifted = &'tcx List<Ty<'tcx>>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for &'a PredicateInner<'a>

type Lifted = &'tcx PredicateInner<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ConstValue<'a>

type Lifted = ConstValue<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ConstValue<'tcx>>

impl<'a, 'tcx> Lift<'tcx> for Adjust<'a>

type Lifted = Adjust<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for AutoBorrow<'a>

type Lifted = AutoBorrow<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for PredicateKind<'a>

type Lifted = PredicateKind<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for TypeError<'a>

type Lifted = TypeError<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for InstanceDef<'a>

type Lifted = InstanceDef<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ExistentialPredicate<'a>

type Lifted = ExistentialPredicate<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for Adjustment<'a>

type Lifted = Adjustment<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for OverloadedDeref<'a>

type Lifted = OverloadedDeref<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ParamEnv<'a>

type Lifted = ParamEnv<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ProjectionPredicate<'a>

type Lifted = ProjectionPredicate<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ProjectionPredicate<'tcx>>

impl<'a, 'tcx> Lift<'tcx> for SubtypePredicate<'a>

type Lifted = SubtypePredicate<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<SubtypePredicate<'tcx>>

impl<'a, 'tcx> Lift<'tcx> for TraitPredicate<'a>

type Lifted = TraitPredicate<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<TraitPredicate<'tcx>>

impl<'a, 'tcx> Lift<'tcx> for ClosureSubsts<'a>

type Lifted = ClosureSubsts<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ExistentialProjection<'a>

type Lifted = ExistentialProjection<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ExistentialTraitRef<'a>

type Lifted = ExistentialTraitRef<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for FnSig<'a>

type Lifted = FnSig<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for GenSig<'a>

type Lifted = GenSig<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for GeneratorSubsts<'a>

type Lifted = GeneratorSubsts<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for ProjectionTy<'a>

type Lifted = ProjectionTy<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ProjectionTy<'tcx>>

impl<'a, 'tcx> Lift<'tcx> for TraitRef<'a>

type Lifted = TraitRef<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for GenericArg<'a>

type Lifted = GenericArg<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for Region<'a>

type Lifted = Region<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx> Lift<'tcx> for Ty<'a>

type Lifted = Ty<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx, T: Lift<'tcx>> Lift<'tcx> for ParamEnvAnd<'a, T>

type Lifted = ParamEnvAnd<'tcx, T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'a, 'tcx, T: Lift<'tcx>> Lift<'tcx> for Binder<'a, T> where
    <T as Lift<'tcx>>::Lifted: TypeFoldable<'tcx>, 

type Lifted = Binder<'tcx, T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx> Lift<'tcx> for CanonicalVarKind<'tcx>

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Certainty

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for NotConstEvaluatable

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for BindingForm<'tcx>

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for FakeReadCause

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for MirPhase

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Mutability

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for RetagKind

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ErrorHandled

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Reveal

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for StatementAsExpression

type Lifted = StatementAsExpression

fn lift_to_tcx(self, _tcx: TyCtxt<'tcx>) -> Option<StatementAsExpression>

impl<'tcx> Lift<'tcx> for AutoBorrowMutability

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for PointerCast

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for AdtKind

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for BindingMode

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ClosureKind

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for FloatTy

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for InferTy

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for IntVarValue

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Variance

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for BoundRegionKind

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for CanonicalVarInfo<'tcx>

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Scope

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for CounterValueReference

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ExpressionOperandId

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for InjectedExpressionId

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for InjectedExpressionIndex

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for MappedExpressionIndex

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for GraphIsCyclicCache

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for PredecessorCache

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for BlockTailInfo

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Local

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Promoted

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for SourceInfo

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for SourceScope

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for SourceScopeLocalData

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for IfExpressionCause

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ImplSourceDiscriminantKindData

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ImplSourcePointeeData

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for AssocItem

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for Placeholder<BoundRegionKind>

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for UniverseIndex

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for FreeRegion

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ParamConst

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ParamTy

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for RegionVid

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for UserTypeAnnotationIndex

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx> Lift<'tcx> for ProjectionKind

type Lifted = Self

fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>

impl<'tcx, '__lifted> Lift<'__lifted> for ConstantKind<'tcx>

type Lifted = ConstantKind<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ConstantKind<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for ObligationCauseCode<'tcx>

type Lifted = ObligationCauseCode<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ObligationCauseCode<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for SelectionError<'tcx>

type Lifted = SelectionError<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<SelectionError<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for OutlivesBound<'tcx>

type Lifted = OutlivesBound<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<OutlivesBound<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for UserType<'tcx>

type Lifted = UserType<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<UserType<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for CanonicalVarValues<'tcx>

type Lifted = CanonicalVarValues<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<CanonicalVarValues<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for QueryRegionConstraints<'tcx>

type Lifted = QueryRegionConstraints<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<QueryRegionConstraints<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for MemberConstraint<'tcx>

type Lifted = MemberConstraint<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<MemberConstraint<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for GlobalId<'tcx>

type Lifted = GlobalId<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<GlobalId<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for DropckOutlivesResult<'tcx>

type Lifted = DropckOutlivesResult<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<DropckOutlivesResult<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for NormalizationResult<'tcx>

type Lifted = NormalizationResult<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<NormalizationResult<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for AscribeUserType<'tcx>

type Lifted = AscribeUserType<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<AscribeUserType<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for Eq<'tcx>

type Lifted = Eq<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<Eq<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for ProvePredicate<'tcx>

type Lifted = ProvePredicate<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ProvePredicate<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for Subtype<'tcx>

type Lifted = Subtype<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<Subtype<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for DerivedObligationCause<'tcx>

type Lifted = DerivedObligationCause<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<DerivedObligationCause<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for MatchExpressionArmCause<'tcx>

type Lifted = MatchExpressionArmCause<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<MatchExpressionArmCause<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for ObligationCause<'tcx>

type Lifted = ObligationCause<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ObligationCause<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for ObligationCauseData<'tcx>

type Lifted = ObligationCauseData<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ObligationCauseData<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for UnifyReceiverContext<'tcx>

type Lifted = UnifyReceiverContext<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<UnifyReceiverContext<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for Instance<'tcx>

type Lifted = Instance<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<Instance<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for TraitRefPrintOnlyTraitPath<'tcx>

type Lifted = TraitRefPrintOnlyTraitPath<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<TraitRefPrintOnlyTraitPath<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for Predicate<'tcx>

type Lifted = Predicate<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<Predicate<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for TypeAndMut<'tcx>

type Lifted = TypeAndMut<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<TypeAndMut<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for UserSelfTy<'tcx>

type Lifted = UserSelfTy<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<UserSelfTy<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for UserSubsts<'tcx>

type Lifted = UserSubsts<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<UserSubsts<'__lifted>>

impl<'tcx, '__lifted> Lift<'__lifted> for CanonicalUserTypeAnnotation<'tcx>

type Lifted = CanonicalUserTypeAnnotation<'__lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<CanonicalUserTypeAnnotation<'__lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSource<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSource<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSource<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSourceClosureData<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceClosureData<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceClosureData<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSourceFnPointerData<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceFnPointerData<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceFnPointerData<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSourceGeneratorData<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceGeneratorData<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceGeneratorData<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSourceObjectData<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceObjectData<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceObjectData<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSourceTraitAliasData<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceTraitAliasData<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceTraitAliasData<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, N> Lift<'__lifted> for ImplSourceUserDefinedData<'tcx, N> where
    N: Lift<'__lifted>, 

type Lifted = ImplSourceUserDefinedData<'__lifted, N::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<ImplSourceUserDefinedData<'__lifted, N::Lifted>>

impl<'tcx, '__lifted, R> Lift<'__lifted> for QueryResponse<'tcx, R> where
    R: Lift<'__lifted>, 

type Lifted = QueryResponse<'__lifted, R::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<QueryResponse<'__lifted, R::Lifted>>

impl<'tcx, '__lifted, V> Lift<'__lifted> for Canonical<'tcx, V> where
    V: Lift<'__lifted>, 

type Lifted = Canonical<'__lifted, V::Lifted>

fn lift_to_tcx(
    self,
    __tcx: TyCtxt<'__lifted>
) -> Option<Canonical<'__lifted, V::Lifted>>

impl<'tcx, A: Copy + Lift<'tcx>, B: Copy + Lift<'tcx>> Lift<'tcx> for OutlivesPredicate<A, B>

type Lifted = OutlivesPredicate<A::Lifted, B::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for ExpectedFound<T>

type Lifted = ExpectedFound<T::Lifted>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>