pub fn walk_tys(&self) -> IntoIter<Ty<'tcx>> {
        let vec: Vec<_> = match *self {
            ty::Predicate::Trait(ref data) => {
                data.skip_binder().input_types().collect()
            }
            ty::Predicate::Equate(ty::Binder(ref data)) => {
                vec![data.0, data.1]
            }
            ty::Predicate::TypeOutlives(ty::Binder(ref data)) => {
                vec![data.0]
            }
            ty::Predicate::RegionOutlives(..) => {
                vec![]
            }
            ty::Predicate::Projection(ref data) => {
                let trait_inputs = data.0.projection_ty.trait_ref.input_types();
                trait_inputs.chain(Some(data.0.ty)).collect()
            }
            ty::Predicate::WellFormed(data) => {
                vec![data]
            }
            ty::Predicate::ObjectSafe(_trait_def_id) => {
                vec![]
            }
            ty::Predicate::ClosureKind(_closure_def_id, _kind) => {
                vec![]
            }
        };

        // The only reason to collect into a vector here is that I was
        // too lazy to make the full (somewhat complicated) iterator
        // type that would be needed here. But I wanted this fn to
        // return an iterator conceptually, rather than a `Vec`, so as
        // to be closer to `Ty::walk`.
        vec.into_iter()
    }
/// Iterates over the types in this predicate. Note that in all
/// cases this is skipping over a binder, so late-bound regions
/// with depth 0 are bound by the predicate.
Iterates over the types in this predicate. Note that in all
cases this is skipping over a binder, so late-bound regions
with depth 0 are bound by the predicate.
Iterates over the types in this predicate . Note that in all cases this is skipping over a binder so late - bound regions with depth 0 are bound by the predicate .
pub fn walk_tys(&self) -> IntoIter<Ty<'tcx>> {
        let vec: Vec<_> = match *self {
            ty::Predicate::Trait(ref data) => {
                data.skip_binder().input_types().collect()
            }
            ty::Predicate::Equate(ty::Binder(ref data)) => {
                vec![data.0, data.1]
            }
            ty::Predicate::TypeOutlives(ty::Binder(ref data)) => {
                vec![data.0]
            }
            ty::Predicate::RegionOutlives(..) => {
                vec![]
            }
            ty::Predicate::Projection(ref data) => {
                let trait_inputs = data.0.projection_ty.trait_ref.input_types();
                trait_inputs.chain(Some(data.0.ty)).collect()
            }
            ty::Predicate::WellFormed(data) => {
                vec![data]
            }
            ty::Predicate::ObjectSafe(_trait_def_id) => {
                vec![]
            }
            ty::Predicate::ClosureKind(_closure_def_id, _kind) => {
                vec![]
            }
        };
        // The only reason to collect into a vector here is that I was
        // too lazy to make the full (somewhat complicated) iterator
        // type that would be needed here. But I wanted this fn to
        // return an iterator conceptually, rather than a `Vec`, so as
        // to be closer to `Ty::walk`.
        vec.into_iter()
    }
pub fn walk_tys ( & self ) -> IntoIter < Ty < ' tcx > > { let vec : Vec < _ > = match * self { ty :: Predicate :: Trait ( ref data ) => { data . skip_binder ( ) . input_types ( ) . collect ( ) } ty :: Predicate :: Equate ( ty :: Binder ( ref data ) ) => { vec ! [ data 0 data 1 ] } ty :: Predicate :: TypeOutlives ( ty :: Binder ( ref data ) ) => { vec ! [ data 0 ] } ty :: Predicate :: RegionOutlives ( .. ) => { vec ! [ ] } ty :: Predicate :: Projection ( ref data ) => { let trait_inputs = data . 0 . projection_ty . trait_ref . input_types ( ) ; trait_inputs . chain ( Some ( data . 0 . ty ) ) . collect ( ) } ty :: Predicate :: WellFormed ( data ) => { vec ! [ data ] } ty :: Predicate :: ObjectSafe ( _trait_def_id ) => { vec ! [ ] } ty :: Predicate :: ClosureKind ( _closure_def_id , _kind ) => { vec ! [ ] } } ; // The only reason to collect into a vector here is that I was // too lazy to make the full (somewhat complicated) iterator // type that would be needed here. But I wanted this fn to // return an iterator conceptually, rather than a `Vec`, so as // to be closer to `Ty::walk`. vec . into_iter ( ) }
Iterates over the types in this predicate.
Iterates over the types in this predicate .
&self