fn select(&mut self, selcx: &mut SelectionContext<'a, 'gcx, 'tcx>)
              -> Result<(),Vec<FulfillmentError<'tcx>>> {
        debug!("select(obligation-forest-size={})", self.predicates.len());

        let mut errors = Vec::new();

        loop {
            debug!("select: starting another iteration");

            // Process pending obligations.
            let outcome = self.predicates.process_obligations(&mut FulfillProcessor {
                selcx,
                register_region_obligations: self.register_region_obligations
            });
            debug!("select: outcome={:#?}", outcome);

            // FIXME: if we kept the original cache key, we could mark projection
            // obligations as complete for the projection cache here.

            errors.extend(
                outcome.errors.into_iter()
                              .map(|e| to_fulfillment_error(e)));

            // If nothing new was added, no need to keep looping.
            if outcome.stalled {
                break;
            }
        }

        debug!("select({} predicates remaining, {} errors) done",
               self.predicates.len(), errors.len());

        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors)
        }
    }
/// Attempts to select obligations using `selcx`.
Attempts to select obligations using `selcx`.
Attempts to select obligations using ` selcx ` .
fn select(&mut self, selcx: &mut SelectionContext<'a, 'gcx, 'tcx>)
              -> Result<(),Vec<FulfillmentError<'tcx>>> {
        debug!("select(obligation-forest-size={})", self.predicates.len());
        let mut errors = Vec::new();
        loop {
            debug!("select: starting another iteration");
            // Process pending obligations.
            let outcome = self.predicates.process_obligations(&mut FulfillProcessor {
                selcx,
                register_region_obligations: self.register_region_obligations
            });
            debug!("select: outcome={:#?}", outcome);
            // FIXME: if we kept the original cache key, we could mark projection
            // obligations as complete for the projection cache here.
            errors.extend(
                outcome.errors.into_iter()
                              .map(|e| to_fulfillment_error(e)));
            // If nothing new was added, no need to keep looping.
            if outcome.stalled {
                break;
            }
        }
        debug!("select({} predicates remaining, {} errors) done",
               self.predicates.len(), errors.len());
        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors)
        }
    }
fn select ( & mut self , selcx : & mut SelectionContext < ' a , ' gcx , ' tcx > ) -> Result < ( ) , Vec < FulfillmentError < ' tcx > > > { debug ! ( " " self predicates len ( ) ) ; let mut errors = Vec :: new ( ) ; loop { debug ! ( " " ) ; // Process pending obligations. let outcome = self . predicates . process_obligations ( & mut FulfillProcessor { selcx , register_region_obligations : self . register_region_obligations } ) ; debug ! ( " " outcome ) ; // FIXME: if we kept the original cache key, we could mark projection // obligations as complete for the projection cache here. errors . extend ( outcome . errors . into_iter ( ) . map ( | e | to_fulfillment_error ( e ) ) ) ; // If nothing new was added, no need to keep looping. if outcome . stalled { break ; } } debug ! ( " " self predicates len ( ) errors len ( ) ) ; if errors . is_empty ( ) { Ok ( ( ) ) } else { Err ( errors ) } }
Attempts to select obligations using `selcx`.
Attempts to select obligations using ` selcx ` .
&mut self
selcx
&mut SelectionContext<'a, 'gcx, 'tcx>
&mut self
selcx
&mut SelectionContext<'a, 'gcx, 'tcx>