src/librustc_typeck/check/method/probe.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use super::MethodError;
  12 use super::NoMatchData;
  13 use super::{CandidateSource, ImplSource, TraitSource};
  14 use super::suggest;
  15
  16 use check;
  17 use check::{FnCtxt, UnresolvedTypeAction};
  18 use middle::def_id::DefId;
  19 use middle::subst;
  20 use middle::subst::Subst;
  21 use middle::traits;
  22 use middle::ty::{self, NoPreference, Ty, ToPolyTraitRef, TraitRef, TypeFoldable};
  23 use middle::infer;
  24 use middle::infer::{InferCtxt, TypeOrigin};
  25 use syntax::ast;
  26 use syntax::codemap::{Span, DUMMY_SP};
  27 use rustc_front::hir;
  28 use std::collections::HashSet;
  29 use std::mem;
  30 use std::rc::Rc;
  31
  32 use self::CandidateKind::*;
  33 pub use self::PickKind::*;
  34
  35 struct ProbeContext<'a, 'tcx:'a> {
  36     fcx: &'a FnCtxt<'a, 'tcx>,
  37     span: Span,
  38     mode: Mode,
  39     item_name: ast::Name,
  40     steps: Rc<Vec<CandidateStep<'tcx>>>,
  41     opt_simplified_steps: Option<Vec<ty::fast_reject::SimplifiedType>>,
  42     inherent_candidates: Vec<Candidate<'tcx>>,
  43     extension_candidates: Vec<Candidate<'tcx>>,
  44     impl_dups: HashSet<DefId>,
  45
  46     /// Collects near misses when the candidate functions are missing a `self` keyword and is only
  47     /// used for error reporting
  48     static_candidates: Vec<CandidateSource>,
  49
  50     /// Collects near misses when trait bounds for type parameters are unsatisfied and is only used
  51     /// for error reporting
  52     unsatisfied_predicates: Vec<TraitRef<'tcx>>
  53 }
  54
  55 #[derive(Debug)]
  56 struct CandidateStep<'tcx> {
  57     self_ty: Ty<'tcx>,
  58     autoderefs: usize,
  59     unsize: bool
  60 }
  61
  62 #[derive(Debug)]
  63 struct Candidate<'tcx> {
  64     xform_self_ty: Ty<'tcx>,
  65     item: ty::ImplOrTraitItem<'tcx>,
  66     kind: CandidateKind<'tcx>,
  67 }
  68
  69 #[derive(Debug)]
  70 enum CandidateKind<'tcx> {
  71     InherentImplCandidate(subst::Substs<'tcx>,
  72                           /* Normalize obligations */ Vec<traits::PredicateObligation<'tcx>>),
  73     ExtensionImplCandidate(/* Impl */ DefId, subst::Substs<'tcx>,
  74                            /* Normalize obligations */ Vec<traits::PredicateObligation<'tcx>>),
  75     ObjectCandidate,
  76     TraitCandidate,
  77     WhereClauseCandidate(/* Trait */ ty::PolyTraitRef<'tcx>),
  78 }
  79
  80 #[derive(Debug)]
  81 pub struct Pick<'tcx> {
  82     pub item: ty::ImplOrTraitItem<'tcx>,
  83     pub kind: PickKind<'tcx>,
  84
  85     // Indicates that the source expression should be autoderef'd N times
  86     //
  87     // A = expr | *expr | **expr | ...
  88     pub autoderefs: usize,
  89
  90     // Indicates that an autoref is applied after the optional autoderefs
  91     //
  92     // B = A | &A | &mut A
  93     pub autoref: Option<hir::Mutability>,
  94
  95     // Indicates that the source expression should be "unsized" to a
  96     // target type. This should probably eventually go away in favor
  97     // of just coercing method receivers.
  98     //
  99     // C = B | unsize(B)
 100     pub unsize: Option<Ty<'tcx>>,
 101 }
 102
 103 #[derive(Clone,Debug)]
 104 pub enum PickKind<'tcx> {
 105     InherentImplPick,
 106     ExtensionImplPick(/* Impl */ DefId),
 107     ObjectPick,
 108     TraitPick,
 109     WhereClausePick(/* Trait */ ty::PolyTraitRef<'tcx>),
 110 }
 111
 112 pub type PickResult<'tcx> = Result<Pick<'tcx>, MethodError<'tcx>>;
 113
 114 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
 115 pub enum Mode {
 116     // An expression of the form `receiver.method_name(...)`.
 117     // Autoderefs are performed on `receiver`, lookup is done based on the
 118     // `self` argument  of the method, and static methods aren't considered.
 119     MethodCall,
 120     // An expression of the form `Type::item` or `<T>::item`.
 121     // No autoderefs are performed, lookup is done based on the type each
 122     // implementation is for, and static methods are included.
 123     Path
 124 }
 125
 126 pub fn probe<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 127                        span: Span,
 128                        mode: Mode,
 129                        item_name: ast::Name,
 130                        self_ty: Ty<'tcx>,
 131                        scope_expr_id: ast::NodeId)
 132                        -> PickResult<'tcx>
 133 {
 134     debug!("probe(self_ty={:?}, item_name={}, scope_expr_id={})",
 135            self_ty,
 136            item_name,
 137            scope_expr_id);
 138
 139     // FIXME(#18741) -- right now, creating the steps involves evaluating the
 140     // `*` operator, which registers obligations that then escape into
 141     // the global fulfillment context and thus has global
 142     // side-effects. This is a bit of a pain to refactor. So just let
 143     // it ride, although it's really not great, and in fact could I
 144     // think cause spurious errors. Really though this part should
 145     // take place in the `fcx.infcx().probe` below.
 146     let steps = if mode == Mode::MethodCall {
 147         match create_steps(fcx, span, self_ty) {
 148             Some(steps) => steps,
 149             None =>return Err(MethodError::NoMatch(NoMatchData::new(Vec::new(), Vec::new(),
 150                                                                     Vec::new(), mode))),
 151         }
 152     } else {
 153         vec![CandidateStep {
 154             self_ty: self_ty,
 155             autoderefs: 0,
 156             unsize: false
 157         }]
 158     };
 159
 160     // Create a list of simplified self types, if we can.
 161     let mut simplified_steps = Vec::new();
 162     for step in &steps {
 163         match ty::fast_reject::simplify_type(fcx.tcx(), step.self_ty, true) {
 164             None => { break; }
 165             Some(simplified_type) => { simplified_steps.push(simplified_type); }
 166         }
 167     }
 168     let opt_simplified_steps =
 169         if simplified_steps.len() < steps.len() {
 170             None // failed to convert at least one of the steps
 171         } else {
 172             Some(simplified_steps)
 173         };
 174
 175     debug!("ProbeContext: steps for self_ty={:?} are {:?}",
 176            self_ty,
 177            steps);
 178
 179     // this creates one big transaction so that all type variables etc
 180     // that we create during the probe process are removed later
 181     fcx.infcx().probe(|_| {
 182         let mut probe_cx = ProbeContext::new(fcx,
 183                                              span,
 184                                              mode,
 185                                              item_name,
 186                                              steps,
 187                                              opt_simplified_steps);
 188         probe_cx.assemble_inherent_candidates();
 189         try!(probe_cx.assemble_extension_candidates_for_traits_in_scope(scope_expr_id));
 190         probe_cx.pick()
 191     })
 192 }
 193
 194 fn create_steps<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 195                           span: Span,
 196                           self_ty: Ty<'tcx>)
 197                           -> Option<Vec<CandidateStep<'tcx>>> {
 198     let mut steps = Vec::new();
 199
 200     let (final_ty, dereferences, _) = check::autoderef(fcx,
 201                                                        span,
 202                                                        self_ty,
 203                                                        None,
 204                                                        UnresolvedTypeAction::Error,
 205                                                        NoPreference,
 206                                                        |t, d| {
 207         steps.push(CandidateStep {
 208             self_ty: t,
 209             autoderefs: d,
 210             unsize: false
 211         });
 212         None::<()> // keep iterating until we can't anymore
 213     });
 214
 215     match final_ty.sty {
 216         ty::TyArray(elem_ty, _) => {
 217             steps.push(CandidateStep {
 218                 self_ty: fcx.tcx().mk_slice(elem_ty),
 219                 autoderefs: dereferences,
 220                 unsize: true
 221             });
 222         }
 223         ty::TyError => return None,
 224         _ => (),
 225     }
 226
 227     Some(steps)
 228 }
 229
 230 impl<'a,'tcx> ProbeContext<'a,'tcx> {
 231     fn new(fcx: &'a FnCtxt<'a,'tcx>,
 232            span: Span,
 233            mode: Mode,
 234            item_name: ast::Name,
 235            steps: Vec<CandidateStep<'tcx>>,
 236            opt_simplified_steps: Option<Vec<ty::fast_reject::SimplifiedType>>)
 237            -> ProbeContext<'a,'tcx>
 238     {
 239         ProbeContext {
 240             fcx: fcx,
 241             span: span,
 242             mode: mode,
 243             item_name: item_name,
 244             inherent_candidates: Vec::new(),
 245             extension_candidates: Vec::new(),
 246             impl_dups: HashSet::new(),
 247             steps: Rc::new(steps),
 248             opt_simplified_steps: opt_simplified_steps,
 249             static_candidates: Vec::new(),
 250             unsatisfied_predicates: Vec::new(),
 251         }
 252     }
 253
 254     fn reset(&mut self) {
 255         self.inherent_candidates.clear();
 256         self.extension_candidates.clear();
 257         self.impl_dups.clear();
 258         self.static_candidates.clear();
 259     }
 260
 261     fn tcx(&self) -> &'a ty::ctxt<'tcx> {
 262         self.fcx.tcx()
 263     }
 264
 265     fn infcx(&self) -> &'a InferCtxt<'a, 'tcx> {
 266         self.fcx.infcx()
 267     }
 268
 269     ///////////////////////////////////////////////////////////////////////////
 270     // CANDIDATE ASSEMBLY
 271
 272     fn assemble_inherent_candidates(&mut self) {
 273         let steps = self.steps.clone();
 274         for step in steps.iter() {
 275             self.assemble_probe(step.self_ty);
 276         }
 277     }
 278
 279     fn assemble_probe(&mut self, self_ty: Ty<'tcx>) {
 280         debug!("assemble_probe: self_ty={:?}",
 281                self_ty);
 282
 283         match self_ty.sty {
 284             ty::TyTrait(box ref data) => {
 285                 self.assemble_inherent_candidates_from_object(self_ty, data);
 286                 self.assemble_inherent_impl_candidates_for_type(data.principal_def_id());
 287             }
 288             ty::TyEnum(def, _) |
 289             ty::TyStruct(def, _) => {
 290                 self.assemble_inherent_impl_candidates_for_type(def.did);
 291             }
 292             ty::TyBox(_) => {
 293                 if let Some(box_did) = self.tcx().lang_items.owned_box() {
 294                     self.assemble_inherent_impl_candidates_for_type(box_did);
 295                 }
 296             }
 297             ty::TyParam(p) => {
 298                 self.assemble_inherent_candidates_from_param(self_ty, p);
 299             }
 300             ty::TyChar => {
 301                 let lang_def_id = self.tcx().lang_items.char_impl();
 302                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 303             }
 304             ty::TyStr => {
 305                 let lang_def_id = self.tcx().lang_items.str_impl();
 306                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 307             }
 308             ty::TySlice(_) => {
 309                 let lang_def_id = self.tcx().lang_items.slice_impl();
 310                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 311             }
 312             ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutImmutable }) => {
 313                 let lang_def_id = self.tcx().lang_items.const_ptr_impl();
 314                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 315             }
 316             ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutMutable }) => {
 317                 let lang_def_id = self.tcx().lang_items.mut_ptr_impl();
 318                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 319             }
 320             ty::TyInt(ast::TyI8) => {
 321                 let lang_def_id = self.tcx().lang_items.i8_impl();
 322                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 323             }
 324             ty::TyInt(ast::TyI16) => {
 325                 let lang_def_id = self.tcx().lang_items.i16_impl();
 326                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 327             }
 328             ty::TyInt(ast::TyI32) => {
 329                 let lang_def_id = self.tcx().lang_items.i32_impl();
 330                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 331             }
 332             ty::TyInt(ast::TyI64) => {
 333                 let lang_def_id = self.tcx().lang_items.i64_impl();
 334                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 335             }
 336             ty::TyInt(ast::TyIs) => {
 337                 let lang_def_id = self.tcx().lang_items.isize_impl();
 338                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 339             }
 340             ty::TyUint(ast::TyU8) => {
 341                 let lang_def_id = self.tcx().lang_items.u8_impl();
 342                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 343             }
 344             ty::TyUint(ast::TyU16) => {
 345                 let lang_def_id = self.tcx().lang_items.u16_impl();
 346                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 347             }
 348             ty::TyUint(ast::TyU32) => {
 349                 let lang_def_id = self.tcx().lang_items.u32_impl();
 350                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 351             }
 352             ty::TyUint(ast::TyU64) => {
 353                 let lang_def_id = self.tcx().lang_items.u64_impl();
 354                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 355             }
 356             ty::TyUint(ast::TyUs) => {
 357                 let lang_def_id = self.tcx().lang_items.usize_impl();
 358                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 359             }
 360             ty::TyFloat(ast::TyF32) => {
 361                 let lang_def_id = self.tcx().lang_items.f32_impl();
 362                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 363             }
 364             ty::TyFloat(ast::TyF64) => {
 365                 let lang_def_id = self.tcx().lang_items.f64_impl();
 366                 self.assemble_inherent_impl_for_primitive(lang_def_id);
 367             }
 368             _ => {
 369             }
 370         }
 371     }
 372
 373     fn assemble_inherent_impl_for_primitive(&mut self, lang_def_id: Option<DefId>) {
 374         if let Some(impl_def_id) = lang_def_id {
 375             self.tcx().populate_implementations_for_primitive_if_necessary(impl_def_id);
 376
 377             self.assemble_inherent_impl_probe(impl_def_id);
 378         }
 379     }
 380
 381     fn assemble_inherent_impl_candidates_for_type(&mut self, def_id: DefId) {
 382         // Read the inherent implementation candidates for this type from the
 383         // metadata if necessary.
 384         self.tcx().populate_inherent_implementations_for_type_if_necessary(def_id);
 385
 386         if let Some(impl_infos) = self.tcx().inherent_impls.borrow().get(&def_id) {
 387             for &impl_def_id in impl_infos.iter() {
 388                 self.assemble_inherent_impl_probe(impl_def_id);
 389             }
 390         }
 391     }
 392
 393     fn assemble_inherent_impl_probe(&mut self, impl_def_id: DefId) {
 394         if !self.impl_dups.insert(impl_def_id) {
 395             return; // already visited
 396         }
 397
 398         debug!("assemble_inherent_impl_probe {:?}", impl_def_id);
 399
 400         let item = match impl_item(self.tcx(), impl_def_id, self.item_name) {
 401             Some(m) => m,
 402             None => { return; } // No method with correct name on this impl
 403         };
 404
 405         if !self.has_applicable_self(&item) {
 406             // No receiver declared. Not a candidate.
 407             return self.record_static_candidate(ImplSource(impl_def_id));
 408         }
 409
 410         let (impl_ty, impl_substs) = self.impl_ty_and_substs(impl_def_id);
 411         let impl_ty = impl_ty.subst(self.tcx(), &impl_substs);
 412
 413         // Determine the receiver type that the method itself expects.
 414         let xform_self_ty = self.xform_self_ty(&item, impl_ty, &impl_substs);
 415
 416         // We can't use normalize_associated_types_in as it will pollute the
 417         // fcx's fulfillment context after this probe is over.
 418         let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
 419         let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx());
 420         let traits::Normalized { value: xform_self_ty, obligations } =
 421             traits::normalize(selcx, cause, &xform_self_ty);
 422         debug!("assemble_inherent_impl_probe: xform_self_ty = {:?}",
 423                xform_self_ty);
 424
 425         self.inherent_candidates.push(Candidate {
 426             xform_self_ty: xform_self_ty,
 427             item: item,
 428             kind: InherentImplCandidate(impl_substs, obligations)
 429         });
 430     }
 431
 432     fn assemble_inherent_candidates_from_object(&mut self,
 433                                                 self_ty: Ty<'tcx>,
 434                                                 data: &ty::TraitTy<'tcx>) {
 435         debug!("assemble_inherent_candidates_from_object(self_ty={:?})",
 436                self_ty);
 437
 438         // It is illegal to invoke a method on a trait instance that
 439         // refers to the `Self` type. An error will be reported by
 440         // `enforce_object_limitations()` if the method refers to the
 441         // `Self` type anywhere other than the receiver. Here, we use
 442         // a substitution that replaces `Self` with the object type
 443         // itself. Hence, a `&self` method will wind up with an
 444         // argument type like `&Trait`.
 445         let trait_ref = data.principal_trait_ref_with_self_ty(self.tcx(), self_ty);
 446         self.elaborate_bounds(&[trait_ref], |this, new_trait_ref, item| {
 447             let new_trait_ref = this.erase_late_bound_regions(&new_trait_ref);
 448
 449             let xform_self_ty = this.xform_self_ty(&item,
 450                                                    new_trait_ref.self_ty(),
 451                                                    new_trait_ref.substs);
 452
 453             this.inherent_candidates.push(Candidate {
 454                 xform_self_ty: xform_self_ty,
 455                 item: item,
 456                 kind: ObjectCandidate
 457             });
 458         });
 459     }
 460
 461     fn assemble_inherent_candidates_from_param(&mut self,
 462                                                _rcvr_ty: Ty<'tcx>,
 463                                                param_ty: ty::ParamTy) {
 464         // FIXME -- Do we want to commit to this behavior for param bounds?
 465
 466         let bounds: Vec<_> =
 467             self.fcx.inh.infcx.parameter_environment.caller_bounds
 468             .iter()
 469             .filter_map(|predicate| {
 470                 match *predicate {
 471                     ty::Predicate::Trait(ref trait_predicate) => {
 472                         match trait_predicate.0.trait_ref.self_ty().sty {
 473                             ty::TyParam(ref p) if *p == param_ty => {
 474                                 Some(trait_predicate.to_poly_trait_ref())
 475                             }
 476                             _ => None
 477                         }
 478                     }
 479                     ty::Predicate::Equate(..) |
 480                     ty::Predicate::Projection(..) |
 481                     ty::Predicate::RegionOutlives(..) |
 482                     ty::Predicate::WellFormed(..) |
 483                     ty::Predicate::ObjectSafe(..) |
 484                     ty::Predicate::TypeOutlives(..) => {
 485                         None
 486                     }
 487                 }
 488             })
 489             .collect();
 490
 491         self.elaborate_bounds(&bounds, |this, poly_trait_ref, item| {
 492             let trait_ref =
 493                 this.erase_late_bound_regions(&poly_trait_ref);
 494
 495             let xform_self_ty =
 496                 this.xform_self_ty(&item,
 497                                    trait_ref.self_ty(),
 498                                    trait_ref.substs);
 499
 500             if let Some(ref m) = item.as_opt_method() {
 501                 debug!("found match: trait_ref={:?} substs={:?} m={:?}",
 502                        trait_ref,
 503                        trait_ref.substs,
 504                        m);
 505                 assert_eq!(m.generics.types.get_slice(subst::TypeSpace).len(),
 506                            trait_ref.substs.types.get_slice(subst::TypeSpace).len());
 507                 assert_eq!(m.generics.regions.get_slice(subst::TypeSpace).len(),
 508                            trait_ref.substs.regions().get_slice(subst::TypeSpace).len());
 509                 assert_eq!(m.generics.types.get_slice(subst::SelfSpace).len(),
 510                            trait_ref.substs.types.get_slice(subst::SelfSpace).len());
 511                 assert_eq!(m.generics.regions.get_slice(subst::SelfSpace).len(),
 512                            trait_ref.substs.regions().get_slice(subst::SelfSpace).len());
 513             }
 514
 515             // Because this trait derives from a where-clause, it
 516             // should not contain any inference variables or other
 517             // artifacts. This means it is safe to put into the
 518             // `WhereClauseCandidate` and (eventually) into the
 519             // `WhereClausePick`.
 520             assert!(!trait_ref.substs.types.needs_infer());
 521
 522             this.inherent_candidates.push(Candidate {
 523                 xform_self_ty: xform_self_ty,
 524                 item: item,
 525                 kind: WhereClauseCandidate(poly_trait_ref)
 526             });
 527         });
 528     }
 529
 530     // Do a search through a list of bounds, using a callback to actually
 531     // create the candidates.
 532     fn elaborate_bounds<F>(
 533         &mut self,
 534         bounds: &[ty::PolyTraitRef<'tcx>],
 535         mut mk_cand: F,
 536     ) where
 537         F: for<'b> FnMut(
 538             &mut ProbeContext<'b, 'tcx>,
 539             ty::PolyTraitRef<'tcx>,
 540             ty::ImplOrTraitItem<'tcx>,
 541         ),
 542     {
 543         debug!("elaborate_bounds(bounds={:?})", bounds);
 544
 545         let tcx = self.tcx();
 546         for bound_trait_ref in traits::transitive_bounds(tcx, bounds) {
 547             let item = match trait_item(tcx,
 548                                         bound_trait_ref.def_id(),
 549                                         self.item_name) {
 550                 Some(v) => v,
 551                 None => { continue; }
 552             };
 553
 554             if !self.has_applicable_self(&item) {
 555                 self.record_static_candidate(TraitSource(bound_trait_ref.def_id()));
 556             } else {
 557                 mk_cand(self, bound_trait_ref, item);
 558             }
 559         }
 560     }
 561
 562     fn assemble_extension_candidates_for_traits_in_scope(&mut self,
 563                                                          expr_id: ast::NodeId)
 564                                                          -> Result<(), MethodError<'tcx>>
 565     {
 566         let mut duplicates = HashSet::new();
 567         let opt_applicable_traits = self.fcx.ccx.trait_map.get(&expr_id);
 568         if let Some(applicable_traits) = opt_applicable_traits {
 569             for &trait_did in applicable_traits {
 570                 if duplicates.insert(trait_did) {
 571                     try!(self.assemble_extension_candidates_for_trait(trait_did));
 572                 }
 573             }
 574         }
 575         Ok(())
 576     }
 577
 578     fn assemble_extension_candidates_for_all_traits(&mut self) -> Result<(), MethodError<'tcx>> {
 579         let mut duplicates = HashSet::new();
 580         for trait_info in suggest::all_traits(self.fcx.ccx) {
 581             if duplicates.insert(trait_info.def_id) {
 582                 try!(self.assemble_extension_candidates_for_trait(trait_info.def_id));
 583             }
 584         }
 585         Ok(())
 586     }
 587
 588     fn assemble_extension_candidates_for_trait(&mut self,
 589                                                trait_def_id: DefId)
 590                                                -> Result<(), MethodError<'tcx>>
 591     {
 592         debug!("assemble_extension_candidates_for_trait(trait_def_id={:?})",
 593                trait_def_id);
 594
 595         // Check whether `trait_def_id` defines a method with suitable name:
 596         let trait_items =
 597             self.tcx().trait_items(trait_def_id);
 598         let maybe_item =
 599             trait_items.iter()
 600                        .find(|item| item.name() == self.item_name);
 601         let item = match maybe_item {
 602             Some(i) => i,
 603             None => { return Ok(()); }
 604         };
 605
 606         // Check whether `trait_def_id` defines a method with suitable name:
 607         if !self.has_applicable_self(item) {
 608             debug!("method has inapplicable self");
 609             self.record_static_candidate(TraitSource(trait_def_id));
 610             return Ok(());
 611         }
 612
 613         self.assemble_extension_candidates_for_trait_impls(trait_def_id, item.clone());
 614
 615         try!(self.assemble_closure_candidates(trait_def_id, item.clone()));
 616
 617         self.assemble_projection_candidates(trait_def_id, item.clone());
 618
 619         self.assemble_where_clause_candidates(trait_def_id, item.clone());
 620
 621         Ok(())
 622     }
 623
 624     fn assemble_extension_candidates_for_trait_impls(&mut self,
 625                                                      trait_def_id: DefId,
 626                                                      item: ty::ImplOrTraitItem<'tcx>)
 627     {
 628         let trait_def = self.tcx().lookup_trait_def(trait_def_id);
 629
 630         // FIXME(arielb1): can we use for_each_relevant_impl here?
 631         trait_def.for_each_impl(self.tcx(), |impl_def_id| {
 632             debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={:?} \
 633                                                                   impl_def_id={:?}",
 634                    trait_def_id,
 635                    impl_def_id);
 636
 637             if !self.impl_can_possibly_match(impl_def_id) {
 638                 return;
 639             }
 640
 641             let (_, impl_substs) = self.impl_ty_and_substs(impl_def_id);
 642
 643             debug!("impl_substs={:?}", impl_substs);
 644
 645             let impl_trait_ref =
 646                 self.tcx().impl_trait_ref(impl_def_id)
 647                 .unwrap() // we know this is a trait impl
 648                 .subst(self.tcx(), &impl_substs);
 649
 650             debug!("impl_trait_ref={:?}", impl_trait_ref);
 651
 652             // Determine the receiver type that the method itself expects.
 653             let xform_self_ty =
 654                 self.xform_self_ty(&item,
 655                                    impl_trait_ref.self_ty(),
 656                                    impl_trait_ref.substs);
 657
 658             // Normalize the receiver. We can't use normalize_associated_types_in
 659             // as it will pollute the fcx's fulfillment context after this probe
 660             // is over.
 661             let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
 662             let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx());
 663             let traits::Normalized { value: xform_self_ty, obligations } =
 664                 traits::normalize(selcx, cause, &xform_self_ty);
 665
 666             debug!("xform_self_ty={:?}", xform_self_ty);
 667
 668             self.extension_candidates.push(Candidate {
 669                 xform_self_ty: xform_self_ty,
 670                 item: item.clone(),
 671                 kind: ExtensionImplCandidate(impl_def_id, impl_substs, obligations)
 672             });
 673         });
 674     }
 675
 676     fn impl_can_possibly_match(&self, impl_def_id: DefId) -> bool {
 677         let simplified_steps = match self.opt_simplified_steps {
 678             Some(ref simplified_steps) => simplified_steps,
 679             None => { return true; }
 680         };
 681
 682         let impl_type = self.tcx().lookup_item_type(impl_def_id);
 683         let impl_simplified_type =
 684             match ty::fast_reject::simplify_type(self.tcx(), impl_type.ty, false) {
 685                 Some(simplified_type) => simplified_type,
 686                 None => { return true; }
 687             };
 688
 689         simplified_steps.contains(&impl_simplified_type)
 690     }
 691
 692     fn assemble_closure_candidates(&mut self,
 693                                    trait_def_id: DefId,
 694                                    item: ty::ImplOrTraitItem<'tcx>)
 695                                    -> Result<(), MethodError<'tcx>>
 696     {
 697         // Check if this is one of the Fn,FnMut,FnOnce traits.
 698         let tcx = self.tcx();
 699         let kind = if Some(trait_def_id) == tcx.lang_items.fn_trait() {
 700             ty::FnClosureKind
 701         } else if Some(trait_def_id) == tcx.lang_items.fn_mut_trait() {
 702             ty::FnMutClosureKind
 703         } else if Some(trait_def_id) == tcx.lang_items.fn_once_trait() {
 704             ty::FnOnceClosureKind
 705         } else {
 706             return Ok(());
 707         };
 708
 709         // Check if there is an unboxed-closure self-type in the list of receivers.
 710         // If so, add "synthetic impls".
 711         let steps = self.steps.clone();
 712         for step in steps.iter() {
 713             let closure_def_id = match step.self_ty.sty {
 714                 ty::TyClosure(a, _) => a,
 715                 _ => continue,
 716             };
 717
 718             let closure_kinds = &self.fcx.inh.tables.borrow().closure_kinds;
 719             let closure_kind = match closure_kinds.get(&closure_def_id) {
 720                 Some(&k) => k,
 721                 None => {
 722                     return Err(MethodError::ClosureAmbiguity(trait_def_id));
 723                 }
 724             };
 725
 726             // this closure doesn't implement the right kind of `Fn` trait
 727             if !closure_kind.extends(kind) {
 728                 continue;
 729             }
 730
 731             // create some substitutions for the argument/return type;
 732             // for the purposes of our method lookup, we only take
 733             // receiver type into account, so we can just substitute
 734             // fresh types here to use during substitution and subtyping.
 735             let trait_def = self.tcx().lookup_trait_def(trait_def_id);
 736             let substs = self.infcx().fresh_substs_for_trait(self.span,
 737                                                              &trait_def.generics,
 738                                                              step.self_ty);
 739
 740             let xform_self_ty = self.xform_self_ty(&item,
 741                                                    step.self_ty,
 742                                                    &substs);
 743             self.inherent_candidates.push(Candidate {
 744                 xform_self_ty: xform_self_ty,
 745                 item: item.clone(),
 746                 kind: TraitCandidate
 747             });
 748         }
 749
 750         Ok(())
 751     }
 752
 753     fn assemble_projection_candidates(&mut self,
 754                                       trait_def_id: DefId,
 755                                       item: ty::ImplOrTraitItem<'tcx>)
 756     {
 757         debug!("assemble_projection_candidates(\
 758                trait_def_id={:?}, \
 759                item={:?})",
 760                trait_def_id,
 761                item);
 762
 763         for step in self.steps.iter() {
 764             debug!("assemble_projection_candidates: step={:?}",
 765                    step);
 766
 767             let projection_trait_ref = match step.self_ty.sty {
 768                 ty::TyProjection(ref data) => &data.trait_ref,
 769                 _ => continue,
 770             };
 771
 772             debug!("assemble_projection_candidates: projection_trait_ref={:?}",
 773                    projection_trait_ref);
 774
 775             let trait_predicates = self.tcx().lookup_predicates(projection_trait_ref.def_id);
 776             let bounds = trait_predicates.instantiate(self.tcx(), projection_trait_ref.substs);
 777             let predicates = bounds.predicates.into_vec();
 778             debug!("assemble_projection_candidates: predicates={:?}",
 779                    predicates);
 780             for poly_bound in
 781                 traits::elaborate_predicates(self.tcx(), predicates)
 782                 .filter_map(|p| p.to_opt_poly_trait_ref())
 783                 .filter(|b| b.def_id() == trait_def_id)
 784             {
 785                 let bound = self.erase_late_bound_regions(&poly_bound);
 786
 787                 debug!("assemble_projection_candidates: projection_trait_ref={:?} bound={:?}",
 788                        projection_trait_ref,
 789                        bound);
 790
 791                 if self.infcx().can_equate(&step.self_ty, &bound.self_ty()).is_ok() {
 792                     let xform_self_ty = self.xform_self_ty(&item,
 793                                                            bound.self_ty(),
 794                                                            bound.substs);
 795
 796                     debug!("assemble_projection_candidates: bound={:?} xform_self_ty={:?}",
 797                            bound,
 798                            xform_self_ty);
 799
 800                     self.extension_candidates.push(Candidate {
 801                         xform_self_ty: xform_self_ty,
 802                         item: item.clone(),
 803                         kind: TraitCandidate
 804                     });
 805                 }
 806             }
 807         }
 808     }
 809
 810     fn assemble_where_clause_candidates(&mut self,
 811                                         trait_def_id: DefId,
 812                                         item: ty::ImplOrTraitItem<'tcx>)
 813     {
 814         debug!("assemble_where_clause_candidates(trait_def_id={:?})",
 815                trait_def_id);
 816
 817         let caller_predicates = self.fcx.inh.infcx.parameter_environment.caller_bounds.clone();
 818         for poly_bound in traits::elaborate_predicates(self.tcx(), caller_predicates)
 819                           .filter_map(|p| p.to_opt_poly_trait_ref())
 820                           .filter(|b| b.def_id() == trait_def_id)
 821         {
 822             let bound = self.erase_late_bound_regions(&poly_bound);
 823             let xform_self_ty = self.xform_self_ty(&item,
 824                                                    bound.self_ty(),
 825                                                    bound.substs);
 826
 827             debug!("assemble_where_clause_candidates: bound={:?} xform_self_ty={:?}",
 828                    bound,
 829                    xform_self_ty);
 830
 831             self.extension_candidates.push(Candidate {
 832                 xform_self_ty: xform_self_ty,
 833                 item: item.clone(),
 834                 kind: WhereClauseCandidate(poly_bound)
 835             });
 836         }
 837     }
 838
 839     ///////////////////////////////////////////////////////////////////////////
 840     // THE ACTUAL SEARCH
 841
 842     fn pick(mut self) -> PickResult<'tcx> {
 843         match self.pick_core() {
 844             Some(r) => return r,
 845             None => {}
 846         }
 847
 848         let static_candidates = mem::replace(&mut self.static_candidates, vec![]);
 849         let unsatisfied_predicates = mem::replace(&mut self.unsatisfied_predicates, vec![]);
 850
 851         // things failed, so lets look at all traits, for diagnostic purposes now:
 852         self.reset();
 853
 854         let span = self.span;
 855         let tcx = self.tcx();
 856
 857         try!(self.assemble_extension_candidates_for_all_traits());
 858
 859         let out_of_scope_traits = match self.pick_core() {
 860             Some(Ok(p)) => vec![p.item.container().id()],
 861             Some(Err(MethodError::Ambiguity(v))) => v.into_iter().map(|source| {
 862                 match source {
 863                     TraitSource(id) => id,
 864                     ImplSource(impl_id) => {
 865                         match tcx.trait_id_of_impl(impl_id) {
 866                             Some(id) => id,
 867                             None =>
 868                                 tcx.sess.span_bug(span,
 869                                                   "found inherent method when looking at traits")
 870                         }
 871                     }
 872                 }
 873             }).collect(),
 874             Some(Err(MethodError::NoMatch(NoMatchData { out_of_scope_traits: others, .. }))) => {
 875                 assert!(others.is_empty());
 876                 vec![]
 877             }
 878             Some(Err(MethodError::ClosureAmbiguity(..))) => {
 879                 // this error only occurs when assembling candidates
 880                 tcx.sess.span_bug(span, "encountered ClosureAmbiguity from pick_core");
 881             }
 882             None => vec![],
 883         };
 884
 885         Err(MethodError::NoMatch(NoMatchData::new(static_candidates, unsatisfied_predicates,
 886                                                   out_of_scope_traits, self.mode)))
 887     }
 888
 889     fn pick_core(&mut self) -> Option<PickResult<'tcx>> {
 890         let steps = self.steps.clone();
 891
 892         // find the first step that works
 893         steps.iter().filter_map(|step| self.pick_step(step)).next()
 894     }
 895
 896     fn pick_step(&mut self, step: &CandidateStep<'tcx>) -> Option<PickResult<'tcx>> {
 897         debug!("pick_step: step={:?}", step);
 898
 899         if step.self_ty.references_error() {
 900             return None;
 901         }
 902
 903         match self.pick_by_value_method(step) {
 904             Some(result) => return Some(result),
 905             None => {}
 906         }
 907
 908         self.pick_autorefd_method(step)
 909     }
 910
 911     fn pick_by_value_method(&mut self,
 912                             step: &CandidateStep<'tcx>)
 913                             -> Option<PickResult<'tcx>>
 914     {
 915         /*!
 916          * For each type `T` in the step list, this attempts to find a
 917          * method where the (transformed) self type is exactly `T`. We
 918          * do however do one transformation on the adjustment: if we
 919          * are passing a region pointer in, we will potentially
 920          * *reborrow* it to a shorter lifetime. This allows us to
 921          * transparently pass `&mut` pointers, in particular, without
 922          * consuming them for their entire lifetime.
 923          */
 924
 925         if step.unsize {
 926             return None;
 927         }
 928
 929         self.pick_method(step.self_ty).map(|r| r.map(|mut pick| {
 930             pick.autoderefs = step.autoderefs;
 931
 932             // Insert a `&*` or `&mut *` if this is a reference type:
 933             if let ty::TyRef(_, mt) = step.self_ty.sty {
 934                 pick.autoderefs += 1;
 935                 pick.autoref = Some(mt.mutbl);
 936             }
 937
 938             pick
 939         }))
 940     }
 941
 942     fn pick_autorefd_method(&mut self,
 943                             step: &CandidateStep<'tcx>)
 944                             -> Option<PickResult<'tcx>>
 945     {
 946         let tcx = self.tcx();
 947
 948         // In general, during probing we erase regions. See
 949         // `impl_self_ty()` for an explanation.
 950         let region = tcx.mk_region(ty::ReStatic);
 951
 952         // Search through mutabilities in order to find one where pick works:
 953         [hir::MutImmutable, hir::MutMutable].iter().filter_map(|&m| {
 954             let autoref_ty = tcx.mk_ref(region, ty::TypeAndMut {
 955                 ty: step.self_ty,
 956                 mutbl: m
 957             });
 958             self.pick_method(autoref_ty).map(|r| r.map(|mut pick| {
 959                 pick.autoderefs = step.autoderefs;
 960                 pick.autoref = Some(m);
 961                 pick.unsize = if step.unsize {
 962                     Some(step.self_ty)
 963                 } else {
 964                     None
 965                 };
 966                 pick
 967             }))
 968         }).nth(0)
 969     }
 970
 971     fn pick_method(&mut self, self_ty: Ty<'tcx>) -> Option<PickResult<'tcx>> {
 972         debug!("pick_method(self_ty={})", self.infcx().ty_to_string(self_ty));
 973
 974         let mut possibly_unsatisfied_predicates = Vec::new();
 975
 976         debug!("searching inherent candidates");
 977         match self.consider_candidates(self_ty, &self.inherent_candidates,
 978                                        &mut possibly_unsatisfied_predicates) {
 979             None => {}
 980             Some(pick) => {
 981                 return Some(pick);
 982             }
 983         }
 984
 985         debug!("searching extension candidates");
 986         let res = self.consider_candidates(self_ty, &self.extension_candidates,
 987                                            &mut possibly_unsatisfied_predicates);
 988         if let None = res {
 989             self.unsatisfied_predicates.extend(possibly_unsatisfied_predicates);
 990         }
 991         res
 992     }
 993
 994     fn consider_candidates(&self,
 995                            self_ty: Ty<'tcx>,
 996                            probes: &[Candidate<'tcx>],
 997                            possibly_unsatisfied_predicates: &mut Vec<TraitRef<'tcx>>)
 998                            -> Option<PickResult<'tcx>> {
 999         let mut applicable_candidates: Vec<_> =
1000             probes.iter()
1001                   .filter(|&probe| self.consider_probe(self_ty,
1002                                                        probe,possibly_unsatisfied_predicates))
1003                   .collect();
1004
1005         debug!("applicable_candidates: {:?}", applicable_candidates);
1006
1007         if applicable_candidates.len() > 1 {
1008             match self.collapse_candidates_to_trait_pick(&applicable_candidates[..]) {
1009                 Some(pick) => { return Some(Ok(pick)); }
1010                 None => { }
1011             }
1012         }
1013
1014         if applicable_candidates.len() > 1 {
1015             let sources = probes.iter().map(|p| p.to_source()).collect();
1016             return Some(Err(MethodError::Ambiguity(sources)));
1017         }
1018
1019         applicable_candidates.pop().map(|probe| {
1020             Ok(probe.to_unadjusted_pick())
1021         })
1022     }
1023
1024     fn consider_probe(&self, self_ty: Ty<'tcx>, probe: &Candidate<'tcx>,
1025                       possibly_unsatisfied_predicates: &mut Vec<TraitRef<'tcx>>) -> bool {
1026         debug!("consider_probe: self_ty={:?} probe={:?}",
1027                self_ty,
1028                probe);
1029
1030         self.infcx().probe(|_| {
1031             // First check that the self type can be related.
1032             match self.make_sub_ty(self_ty, probe.xform_self_ty) {
1033                 Ok(()) => { }
1034                 Err(_) => {
1035                     debug!("--> cannot relate self-types");
1036                     return false;
1037                 }
1038             }
1039
1040             // If so, impls may carry other conditions (e.g., where
1041             // clauses) that must be considered. Make sure that those
1042             // match as well (or at least may match, sometimes we
1043             // don't have enough information to fully evaluate).
1044             let (impl_def_id, substs, ref_obligations) = match probe.kind {
1045                 InherentImplCandidate(ref substs, ref ref_obligations) => {
1046                     (probe.item.container().id(), substs, ref_obligations)
1047                 }
1048
1049                 ExtensionImplCandidate(impl_def_id, ref substs, ref ref_obligations) => {
1050                     (impl_def_id, substs, ref_obligations)
1051                 }
1052
1053                 ObjectCandidate |
1054                 TraitCandidate |
1055                 WhereClauseCandidate(..) => {
1056                     // These have no additional conditions to check.
1057                     return true;
1058                 }
1059             };
1060
1061             let selcx = &mut traits::SelectionContext::new(self.infcx());
1062             let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
1063
1064             // Check whether the impl imposes obligations we have to worry about.
1065             let impl_bounds = self.tcx().lookup_predicates(impl_def_id);
1066             let impl_bounds = impl_bounds.instantiate(self.tcx(), substs);
1067             let traits::Normalized { value: impl_bounds,
1068                                         obligations: norm_obligations } =
1069                 traits::normalize(selcx, cause.clone(), &impl_bounds);
1070
1071             // Convert the bounds into obligations.
1072             let obligations =
1073                 traits::predicates_for_generics(cause.clone(),
1074                                                 &impl_bounds);
1075             debug!("impl_obligations={:?}", obligations);
1076
1077             // Evaluate those obligations to see if they might possibly hold.
1078             let mut all_true = true;
1079             for o in obligations.iter()
1080                 .chain(norm_obligations.iter())
1081                 .chain(ref_obligations.iter()) {
1082                 if !selcx.evaluate_obligation(o) {
1083                     all_true = false;
1084                     if let &ty::Predicate::Trait(ref pred) = &o.predicate {
1085                         possibly_unsatisfied_predicates.push(pred.0.trait_ref);
1086                     }
1087                 }
1088             }
1089             all_true
1090         })
1091     }
1092
1093     /// Sometimes we get in a situation where we have multiple probes that are all impls of the
1094     /// same trait, but we don't know which impl to use. In this case, since in all cases the
1095     /// external interface of the method can be determined from the trait, it's ok not to decide.
1096     /// We can basically just collapse all of the probes for various impls into one where-clause
1097     /// probe. This will result in a pending obligation so when more type-info is available we can
1098     /// make the final decision.
1099     ///
1100     /// Example (`src/test/run-pass/method-two-trait-defer-resolution-1.rs`):
1101     ///
1102     /// ```
1103     /// trait Foo { ... }
1104     /// impl Foo for Vec<int> { ... }
1105     /// impl Foo for Vec<usize> { ... }
1106     /// ```
1107     ///
1108     /// Now imagine the receiver is `Vec<_>`. It doesn't really matter at this time which impl we
1109     /// use, so it's ok to just commit to "using the method from the trait Foo".
1110     fn collapse_candidates_to_trait_pick(&self,
1111                                          probes: &[&Candidate<'tcx>])
1112                                          -> Option<Pick<'tcx>> {
1113         // Do all probes correspond to the same trait?
1114         let container = probes[0].item.container();
1115         match container {
1116             ty::TraitContainer(_) => {}
1117             ty::ImplContainer(_) => return None
1118         }
1119         if probes[1..].iter().any(|p| p.item.container() != container) {
1120             return None;
1121         }
1122
1123         // If so, just use this trait and call it a day.
1124         Some(Pick {
1125             item: probes[0].item.clone(),
1126             kind: TraitPick,
1127             autoderefs: 0,
1128             autoref: None,
1129             unsize: None
1130         })
1131     }
1132
1133     ///////////////////////////////////////////////////////////////////////////
1134     // MISCELLANY
1135
1136     fn make_sub_ty(&self, sub: Ty<'tcx>, sup: Ty<'tcx>) -> infer::UnitResult<'tcx> {
1137         self.infcx().sub_types(false, TypeOrigin::Misc(DUMMY_SP), sub, sup)
1138     }
1139
1140     fn has_applicable_self(&self, item: &ty::ImplOrTraitItem) -> bool {
1141         // "fast track" -- check for usage of sugar
1142         match *item {
1143             ty::ImplOrTraitItem::MethodTraitItem(ref method) =>
1144                 match method.explicit_self {
1145                     ty::ExplicitSelfCategory::Static => self.mode == Mode::Path,
1146                     ty::ExplicitSelfCategory::ByValue |
1147                     ty::ExplicitSelfCategory::ByReference(..) |
1148                     ty::ExplicitSelfCategory::ByBox => true,
1149                 },
1150             ty::ImplOrTraitItem::ConstTraitItem(..) => self.mode == Mode::Path,
1151             _ => false,
1152         }
1153         // FIXME -- check for types that deref to `Self`,
1154         // like `Rc<Self>` and so on.
1155         //
1156         // Note also that the current code will break if this type
1157         // includes any of the type parameters defined on the method
1158         // -- but this could be overcome.
1159     }
1160
1161     fn record_static_candidate(&mut self, source: CandidateSource) {
1162         self.static_candidates.push(source);
1163     }
1164
1165     fn xform_self_ty(&self,
1166                      item: &ty::ImplOrTraitItem<'tcx>,
1167                      impl_ty: Ty<'tcx>,
1168                      substs: &subst::Substs<'tcx>)
1169                      -> Ty<'tcx>
1170     {
1171         match item.as_opt_method() {
1172             Some(ref method) => self.xform_method_self_ty(method, impl_ty,
1173                                                           substs),
1174             None => impl_ty,
1175         }
1176     }
1177
1178     fn xform_method_self_ty(&self,
1179                             method: &Rc<ty::Method<'tcx>>,
1180                             impl_ty: Ty<'tcx>,
1181                             substs: &subst::Substs<'tcx>)
1182                             -> Ty<'tcx>
1183     {
1184         debug!("xform_self_ty(impl_ty={:?}, self_ty={:?}, substs={:?})",
1185                impl_ty,
1186                method.fty.sig.0.inputs.get(0),
1187                substs);
1188
1189         assert!(!substs.has_escaping_regions());
1190
1191         // It is possible for type parameters or early-bound lifetimes
1192         // to appear in the signature of `self`. The substitutions we
1193         // are given do not include type/lifetime parameters for the
1194         // method yet. So create fresh variables here for those too,
1195         // if there are any.
1196         assert_eq!(substs.types.len(subst::FnSpace), 0);
1197         assert_eq!(substs.regions().len(subst::FnSpace), 0);
1198
1199         if self.mode == Mode::Path {
1200             return impl_ty;
1201         }
1202
1203         let mut placeholder;
1204         let mut substs = substs;
1205         if
1206             !method.generics.types.is_empty_in(subst::FnSpace) ||
1207             !method.generics.regions.is_empty_in(subst::FnSpace)
1208         {
1209             // In general, during probe we erase regions. See
1210             // `impl_self_ty()` for an explanation.
1211             let method_regions =
1212                 method.generics.regions.get_slice(subst::FnSpace)
1213                 .iter()
1214                 .map(|_| ty::ReStatic)
1215                 .collect();
1216
1217             placeholder = (*substs).clone().with_method(Vec::new(), method_regions);
1218
1219             self.infcx().type_vars_for_defs(
1220                 self.span,
1221                 subst::FnSpace,
1222                 &mut placeholder,
1223                 method.generics.types.get_slice(subst::FnSpace));
1224
1225             substs = &placeholder;
1226         }
1227
1228         // Erase any late-bound regions from the method and substitute
1229         // in the values from the substitution.
1230         let xform_self_ty = method.fty.sig.input(0);
1231         let xform_self_ty = self.erase_late_bound_regions(&xform_self_ty);
1232         let xform_self_ty = xform_self_ty.subst(self.tcx(), substs);
1233
1234         xform_self_ty
1235     }
1236
1237     /// Get the type of an impl and generate substitutions with placeholders.
1238     fn impl_ty_and_substs(&self,
1239                           impl_def_id: DefId)
1240                           -> (Ty<'tcx>, subst::Substs<'tcx>)
1241     {
1242         let impl_pty = self.tcx().lookup_item_type(impl_def_id);
1243
1244         let type_vars =
1245             impl_pty.generics.types.map(
1246                 |_| self.infcx().next_ty_var());
1247
1248         let region_placeholders =
1249             impl_pty.generics.regions.map(
1250                 |_| ty::ReStatic); // see erase_late_bound_regions() for an expl of why 'static
1251
1252         let substs = subst::Substs::new(type_vars, region_placeholders);
1253         (impl_pty.ty, substs)
1254     }
1255
1256     /// Replace late-bound-regions bound by `value` with `'static` using
1257     /// `ty::erase_late_bound_regions`.
1258     ///
1259     /// This is only a reasonable thing to do during the *probe* phase, not the *confirm* phase, of
1260     /// method matching. It is reasonable during the probe phase because we don't consider region
1261     /// relationships at all. Therefore, we can just replace all the region variables with 'static
1262     /// rather than creating fresh region variables. This is nice for two reasons:
1263     ///
1264     /// 1. Because the numbers of the region variables would otherwise be fairly unique to this
1265     ///    particular method call, it winds up creating fewer types overall, which helps for memory
1266     ///    usage. (Admittedly, this is a rather small effect, though measureable.)
1267     ///
1268     /// 2. It makes it easier to deal with higher-ranked trait bounds, because we can replace any
1269     ///    late-bound regions with 'static. Otherwise, if we were going to replace late-bound
1270     ///    regions with actual region variables as is proper, we'd have to ensure that the same
1271     ///    region got replaced with the same variable, which requires a bit more coordination
1272     ///    and/or tracking the substitution and
1273     ///    so forth.
1274     fn erase_late_bound_regions<T>(&self, value: &ty::Binder<T>) -> T
1275         where T : TypeFoldable<'tcx>
1276     {
1277         self.tcx().erase_late_bound_regions(value)
1278     }
1279 }
1280
1281 fn impl_item<'tcx>(tcx: &ty::ctxt<'tcx>,
1282                    impl_def_id: DefId,
1283                    item_name: ast::Name)
1284                    -> Option<ty::ImplOrTraitItem<'tcx>>
1285 {
1286     let impl_items = tcx.impl_items.borrow();
1287     let impl_items = impl_items.get(&impl_def_id).unwrap();
1288     impl_items
1289         .iter()
1290         .map(|&did| tcx.impl_or_trait_item(did.def_id()))
1291         .find(|item| item.name() == item_name)
1292 }
1293
1294 /// Find item with name `item_name` defined in `trait_def_id`
1295 /// and return it, or `None`, if no such item.
1296 fn trait_item<'tcx>(tcx: &ty::ctxt<'tcx>,
1297                     trait_def_id: DefId,
1298                     item_name: ast::Name)
1299                     -> Option<ty::ImplOrTraitItem<'tcx>>
1300 {
1301     let trait_items = tcx.trait_items(trait_def_id);
1302     debug!("trait_method; items: {:?}", trait_items);
1303     trait_items.iter()
1304                .find(|item| item.name() == item_name)
1305                .cloned()
1306 }
1307
1308 impl<'tcx> Candidate<'tcx> {
1309     fn to_unadjusted_pick(&self) -> Pick<'tcx> {
1310         Pick {
1311             item: self.item.clone(),
1312             kind: match self.kind {
1313                 InherentImplCandidate(_, _) => InherentImplPick,
1314                 ExtensionImplCandidate(def_id, _, _) => {
1315                     ExtensionImplPick(def_id)
1316                 }
1317                 ObjectCandidate => ObjectPick,
1318                 TraitCandidate => TraitPick,
1319                 WhereClauseCandidate(ref trait_ref) => {
1320                     // Only trait derived from where-clauses should
1321                     // appear here, so they should not contain any
1322                     // inference variables or other artifacts. This
1323                     // means they are safe to put into the
1324                     // `WhereClausePick`.
1325                     assert!(!trait_ref.substs().types.needs_infer());
1326
1327                     WhereClausePick(trait_ref.clone())
1328                 }
1329             },
1330             autoderefs: 0,
1331             autoref: None,
1332             unsize: None
1333         }
1334     }
1335
1336     fn to_source(&self) -> CandidateSource {
1337         match self.kind {
1338             InherentImplCandidate(_, _) => {
1339                 ImplSource(self.item.container().id())
1340             }
1341             ExtensionImplCandidate(def_id, _, _) => ImplSource(def_id),
1342             ObjectCandidate |
1343             TraitCandidate |
1344             WhereClauseCandidate(_) => TraitSource(self.item.container().id()),
1345         }
1346     }
1347 }