fn rematch_impl(&mut self,
                    impl_def_id: ast::DefId,
                    obligation: &Obligation<'tcx>)
                    -> Substs<'tcx>
    {
        match self.match_impl(impl_def_id, obligation) {
            Ok(substs) => {
                substs
            }
            Err(()) => {
                self.tcx().sess.bug(
                    format!("Impl {} was matchable against {} but now is not",
                            impl_def_id.repr(self.tcx()),
                            obligation.repr(self.tcx()))
                        .as_slice());
            }
        }
    }
///////////////////////////////////////////////////////////////////////////
// Matching
//
// Matching is a common path used for both evaluation and
// confirmation.  It basically unifies types that appear in impls
// and traits. This does affect the surrounding environment;
// therefore, when used during evaluation, match routines must be
// run inside of a `probe()` so that their side-effects are
// contained.
Matching
Matching is a common path used for both evaluation and
confirmation.  It basically unifies types that appear in impls
and traits. This does affect the surrounding environment;
therefore, when used during evaluation, match routines must be
run inside of a `probe()` so that their side-effects are
contained.
Matching Matching is a common path used for both evaluation and confirmation . It basically unifies types that appear in impls and traits . This does affect the surrounding environment ; therefore when used during evaluation match routines must be run inside of a ` probe () ` so that their side - effects are contained .
fn rematch_impl(&mut self,
                    impl_def_id: ast::DefId,
                    obligation: &Obligation<'tcx>)
                    -> Substs<'tcx>
    {
        match self.match_impl(impl_def_id, obligation) {
            Ok(substs) => {
                substs
            }
            Err(()) => {
                self.tcx().sess.bug(
                    format!("Impl {} was matchable against {} but now is not",
                            impl_def_id.repr(self.tcx()),
                            obligation.repr(self.tcx()))
                        .as_slice());
            }
        }
    }
fn rematch_impl ( & mut self , impl_def_id : ast :: DefId , obligation : & Obligation < ' tcx > ) -> Substs < ' tcx > { match self . match_impl ( impl_def_id , obligation ) { Ok ( substs ) => { substs } Err ( ( ) ) => { self . tcx ( ) . sess . bug ( format ! ( " " impl_def_id repr ( self tcx ( ) ) obligation repr ( self tcx ( ) ) ) . as_slice ( ) ) ; } } }
Matching
Matching is a common path used for both evaluation and
confirmation.
Matching Matching is a common path used for both evaluation and confirmation .
&mut self
impl_def_id
ast::DefId
obligation
&Obligation<'tcx>