fn assemble_builtin_bound_candidates<'o>(&mut self,
                                             bound: ty::BuiltinBound,
                                             stack: &ObligationStack<'o, 'tcx>,
                                             candidates: &mut CandidateSet<'tcx>)
                                             -> Result<(),SelectionError<'tcx>>
    {
        match self.builtin_bound(bound, stack.obligation.self_ty()) {
            Ok(If(_)) => {
                debug!("builtin_bound: bound={}",
                       bound.repr(self.tcx()));
                candidates.vec.push(BuiltinCandidate(bound));
                Ok(())
            }
            Ok(ParameterBuiltin) => { Ok(()) }
            Ok(AmbiguousBuiltin) => { Ok(candidates.ambiguous = true) }
            Err(e) => { Err(e) }
        }
    }
///////////////////////////////////////////////////////////////////////////
// BUILTIN BOUNDS
//
// These cover the traits that are built-in to the language
// itself.  This includes `Copy` and `Sized` for sure. For the
// moment, it also includes `Send` / `Sync` and a few others, but
// those will hopefully change to library-defined traits in the
// future.
BUILTIN BOUNDS
These cover the traits that are built-in to the language
itself.  This includes `Copy` and `Sized` for sure. For the
moment, it also includes `Send` / `Sync` and a few others, but
those will hopefully change to library-defined traits in the
future.
BUILTIN BOUNDS These cover the traits that are built - in to the language itself . This includes ` Copy ` and ` Sized ` for sure . For the moment it also includes ` Send ` / ` Sync ` and a few others but those will hopefully change to library - defined traits in the future .
fn assemble_builtin_bound_candidates<'o>(&mut self,
                                             bound: ty::BuiltinBound,
                                             stack: &ObligationStack<'o, 'tcx>,
                                             candidates: &mut CandidateSet<'tcx>)
                                             -> Result<(),SelectionError<'tcx>>
    {
        match self.builtin_bound(bound, stack.obligation.self_ty()) {
            Ok(If(_)) => {
                debug!("builtin_bound: bound={}",
                       bound.repr(self.tcx()));
                candidates.vec.push(BuiltinCandidate(bound));
                Ok(())
            }
            Ok(ParameterBuiltin) => { Ok(()) }
            Ok(AmbiguousBuiltin) => { Ok(candidates.ambiguous = true) }
            Err(e) => { Err(e) }
        }
    }
fn assemble_builtin_bound_candidates < ' o > ( & mut self , bound : ty :: BuiltinBound , stack : & ObligationStack < ' o , ' tcx > , candidates : & mut CandidateSet < ' tcx > ) -> Result < ( ) , SelectionError < ' tcx > > { match self . builtin_bound ( bound , stack . obligation . self_ty ( ) ) { Ok ( If ( _ ) ) => { debug ! ( " " bound repr ( self tcx ( ) ) ) ; candidates . vec . push ( BuiltinCandidate ( bound ) ) ; Ok ( ( ) ) } Ok ( ParameterBuiltin ) => { Ok ( ( ) ) } Ok ( AmbiguousBuiltin ) => { Ok ( candidates . ambiguous = true ) } Err ( e ) => { Err ( e ) } } }
BUILTIN BOUNDS
These cover the traits that are built-in to the language
itself.
BUILTIN BOUNDS These cover the traits that are built - in to the language itself .
&mut self
bound
ty::BuiltinBound
stack
&ObligationStack<'o, 'tcx>
candidates
&mut CandidateSet<'tcx>