pub fn struct_lockstep_tails_erasing_lifetimes(self,
                                                   source: Ty<'tcx>,
                                                   target: Ty<'tcx>,
                                                   param_env: ty::ParamEnv<'tcx>)
                                                   -> (Ty<'tcx>, Ty<'tcx>)
    {
        let tcx = self;
        tcx.struct_lockstep_tails_with_normalize(
            source, target, |ty| tcx.normalize_erasing_regions(param_env, ty))
    }
/// Same as applying `struct_tail` on `source` and `target`, but only
/// keeps going as long as the two types are instances of the same
/// structure definitions.
/// For `(Foo<Foo<T>>, Foo<dyn Trait>)`, the result will be `(Foo<T>, Trait)`,
/// whereas struct_tail produces `T`, and `Trait`, respectively.
///
/// Should only be called if the types have no inference variables and do
/// not need their lifetimes preserved (e.g., as part of codegen); otherwise,
/// normalization attempt may cause compiler bugs.


Should only be called if the types have no inference variables and do
not need their lifetimes preserved ; otherwise,
normalization attempt may cause compiler bugs.
Should only be called if the types have no inference variables and do not need their lifetimes preserved ; otherwise normalization attempt may cause compiler bugs .
pub fn struct_lockstep_tails_erasing_lifetimes(self,
                                                   source: Ty<'tcx>,
                                                   target: Ty<'tcx>,
                                                   param_env: ty::ParamEnv<'tcx>)
                                                   -> (Ty<'tcx>, Ty<'tcx>)
    {
        let tcx = self;
        tcx.struct_lockstep_tails_with_normalize(
            source, target, |ty| tcx.normalize_erasing_regions(param_env, ty))
    }
pub fn struct_lockstep_tails_erasing_lifetimes ( self , source : Ty < ' tcx > , target : Ty < ' tcx > , param_env : ty :: ParamEnv < ' tcx > ) -> ( Ty < ' tcx > , Ty < ' tcx > ) { let tcx = self ; tcx . struct_lockstep_tails_with_normalize ( source , target , | ty | tcx . normalize_erasing_regions ( param_env , ty ) ) }
Same as applying `struct_tail` on `source` and `target`, but only
keeps going as long as the two types are instances of the same
structure definitions.
Same as applying ` struct_tail ` on ` source ` and ` target ` but only keeps going as long as the two types are instances of the same structure definitions .
self
source
Ty<'tcx>
target
Ty<'tcx>
param_env
ty::ParamEnv<'tcx>