/// 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.
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.

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.
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 . 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
<not_specific>
source
Ty<'tcx>
<not_specific>
target
Ty<'tcx>
<not_specific>
param_env
ty::ParamEnv<'tcx>
<not_specific>