2 use super::MethodError
;
3 use super::NoMatchData
;
4 use super::{CandidateSource, ImplSource, TraitSource}
;
6 use crate::check
::autoderef
::{self, Autoderef}
;
7 use crate::check
::FnCtxt
;
8 use crate::hir
::def
::DefKind
;
9 use crate::hir
::def_id
::DefId
;
12 use rustc
::middle
::stability
;
13 use rustc
::session
::config
::nightly_options
;
14 use rustc
::ty
::subst
::{InternalSubsts, Subst, SubstsRef}
;
15 use rustc
::ty
::GenericParamDefKind
;
17 self, ParamEnvAnd
, ToPolyTraitRef
, ToPredicate
, Ty
, TyCtxt
, TypeFoldable
, WithConstness
,
20 use rustc_ast
::util
::lev_distance
::{find_best_match_for_name, lev_distance}
;
21 use rustc_data_structures
::fx
::FxHashSet
;
22 use rustc_data_structures
::sync
::Lrc
;
23 use rustc_errors
::struct_span_err
;
25 use rustc_hir
::def
::Namespace
;
26 use rustc_infer
::infer
::canonical
::OriginalQueryValues
;
27 use rustc_infer
::infer
::canonical
::{Canonical, QueryResponse}
;
28 use rustc_infer
::infer
::type_variable
::{TypeVariableOrigin, TypeVariableOriginKind}
;
29 use rustc_infer
::infer
::unify_key
::{ConstVariableOrigin, ConstVariableOriginKind}
;
30 use rustc_infer
::infer
::{self, InferOk, TyCtxtInferExt}
;
31 use rustc_infer
::traits
::query
::method_autoderef
::MethodAutoderefBadTy
;
32 use rustc_infer
::traits
::query
::method_autoderef
::{CandidateStep, MethodAutoderefStepsResult}
;
33 use rustc_infer
::traits
::query
::CanonicalTyGoal
;
34 use rustc_infer
::traits
::{self, ObligationCause}
;
35 use rustc_span
::{symbol::Symbol, Span, DUMMY_SP}
;
41 use smallvec
::{smallvec, SmallVec}
;
43 use self::CandidateKind
::*;
44 pub use self::PickKind
::*;
46 /// Boolean flag used to indicate if this search is for a suggestion
47 /// or not. If true, we can allow ambiguity and so forth.
48 #[derive(Clone, Copy)]
49 pub struct IsSuggestion(pub bool
);
51 struct ProbeContext
<'a
, 'tcx
> {
52 fcx
: &'a FnCtxt
<'a
, 'tcx
>,
55 method_name
: Option
<ast
::Ident
>,
56 return_type
: Option
<Ty
<'tcx
>>,
58 /// This is the OriginalQueryValues for the steps queries
59 /// that are answered in steps.
60 orig_steps_var_values
: OriginalQueryValues
<'tcx
>,
61 steps
: Lrc
<Vec
<CandidateStep
<'tcx
>>>,
63 inherent_candidates
: Vec
<Candidate
<'tcx
>>,
64 extension_candidates
: Vec
<Candidate
<'tcx
>>,
65 impl_dups
: FxHashSet
<DefId
>,
67 /// Collects near misses when the candidate functions are missing a `self` keyword and is only
68 /// used for error reporting
69 static_candidates
: Vec
<CandidateSource
>,
71 /// When probing for names, include names that are close to the
72 /// requested name (by Levensthein distance)
73 allow_similar_names
: bool
,
75 /// Some(candidate) if there is a private candidate
76 private_candidate
: Option
<(DefKind
, DefId
)>,
78 /// Collects near misses when trait bounds for type parameters are unsatisfied and is only used
79 /// for error reporting
80 unsatisfied_predicates
: Vec
<(ty
::Predicate
<'tcx
>, Option
<ty
::Predicate
<'tcx
>>)>,
82 is_suggestion
: IsSuggestion
,
85 impl<'a
, 'tcx
> Deref
for ProbeContext
<'a
, 'tcx
> {
86 type Target
= FnCtxt
<'a
, 'tcx
>;
87 fn deref(&self) -> &Self::Target
{
93 struct Candidate
<'tcx
> {
94 // Candidates are (I'm not quite sure, but they are mostly) basically
95 // some metadata on top of a `ty::AssocItem` (without substs).
97 // However, method probing wants to be able to evaluate the predicates
98 // for a function with the substs applied - for example, if a function
99 // has `where Self: Sized`, we don't want to consider it unless `Self`
100 // is actually `Sized`, and similarly, return-type suggestions want
101 // to consider the "actual" return type.
103 // The way this is handled is through `xform_self_ty`. It contains
104 // the receiver type of this candidate, but `xform_self_ty`,
105 // `xform_ret_ty` and `kind` (which contains the predicates) have the
106 // generic parameters of this candidate substituted with the *same set*
107 // of inference variables, which acts as some weird sort of "query".
109 // When we check out a candidate, we require `xform_self_ty` to be
110 // a subtype of the passed-in self-type, and this equates the type
111 // variables in the rest of the fields.
113 // For example, if we have this candidate:
116 // fn foo(&self) where Self: Sized;
120 // Then `xform_self_ty` will be `&'erased ?X` and `kind` will contain
121 // the predicate `?X: Sized`, so if we are evaluating `Foo` for a
122 // the receiver `&T`, we'll do the subtyping which will make `?X`
123 // get the right value, then when we evaluate the predicate we'll check
125 xform_self_ty
: Ty
<'tcx
>,
126 xform_ret_ty
: Option
<Ty
<'tcx
>>,
128 kind
: CandidateKind
<'tcx
>,
129 import_ids
: SmallVec
<[hir
::HirId
; 1]>,
133 enum CandidateKind
<'tcx
> {
134 InherentImplCandidate(
136 // Normalize obligations
137 Vec
<traits
::PredicateObligation
<'tcx
>>,
140 TraitCandidate(ty
::TraitRef
<'tcx
>),
141 WhereClauseCandidate(
143 ty
::PolyTraitRef
<'tcx
>,
147 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
154 #[derive(Debug, PartialEq, Clone)]
155 pub struct Pick
<'tcx
> {
156 pub item
: ty
::AssocItem
,
157 pub kind
: PickKind
<'tcx
>,
158 pub import_ids
: SmallVec
<[hir
::HirId
; 1]>,
160 // Indicates that the source expression should be autoderef'd N times
162 // A = expr | *expr | **expr | ...
163 pub autoderefs
: usize,
165 // Indicates that an autoref is applied after the optional autoderefs
167 // B = A | &A | &mut A
168 pub autoref
: Option
<hir
::Mutability
>,
170 // Indicates that the source expression should be "unsized" to a
171 // target type. This should probably eventually go away in favor
172 // of just coercing method receivers.
175 pub unsize
: Option
<Ty
<'tcx
>>,
178 #[derive(Clone, Debug, PartialEq, Eq)]
179 pub enum PickKind
<'tcx
> {
185 ty
::PolyTraitRef
<'tcx
>,
189 pub type PickResult
<'tcx
> = Result
<Pick
<'tcx
>, MethodError
<'tcx
>>;
191 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
193 // An expression of the form `receiver.method_name(...)`.
194 // Autoderefs are performed on `receiver`, lookup is done based on the
195 // `self` argument of the method, and static methods aren't considered.
197 // An expression of the form `Type::item` or `<T>::item`.
198 // No autoderefs are performed, lookup is done based on the type each
199 // implementation is for, and static methods are included.
203 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
204 pub enum ProbeScope
{
205 // Assemble candidates coming only from traits in scope.
208 // Assemble candidates coming from all traits.
212 impl<'a
, 'tcx
> FnCtxt
<'a
, 'tcx
> {
213 /// This is used to offer suggestions to users. It returns methods
214 /// that could have been called which have the desired return
215 /// type. Some effort is made to rule out methods that, if called,
216 /// would result in an error (basically, the same criteria we
217 /// would use to decide if a method is a plausible fit for
218 /// ambiguity purposes).
219 pub fn probe_for_return_type(
223 return_type
: Ty
<'tcx
>,
225 scope_expr_id
: hir
::HirId
,
226 ) -> Vec
<ty
::AssocItem
> {
228 "probe(self_ty={:?}, return_type={}, scope_expr_id={})",
229 self_ty
, return_type
, scope_expr_id
231 let method_names
= self
240 ProbeScope
::AllTraits
,
241 |probe_cx
| Ok(probe_cx
.candidate_method_names()),
246 .flat_map(|&method_name
| {
255 ProbeScope
::AllTraits
,
256 |probe_cx
| probe_cx
.pick(),
259 .map(|pick
| pick
.item
)
264 pub fn probe_for_name(
268 item_name
: ast
::Ident
,
269 is_suggestion
: IsSuggestion
,
271 scope_expr_id
: hir
::HirId
,
273 ) -> PickResult
<'tcx
> {
275 "probe(self_ty={:?}, item_name={}, scope_expr_id={})",
276 self_ty
, item_name
, scope_expr_id
287 |probe_cx
| probe_cx
.pick(),
295 method_name
: Option
<ast
::Ident
>,
296 return_type
: Option
<Ty
<'tcx
>>,
297 is_suggestion
: IsSuggestion
,
299 scope_expr_id
: hir
::HirId
,
302 ) -> Result
<R
, MethodError
<'tcx
>>
304 OP
: FnOnce(ProbeContext
<'a
, 'tcx
>) -> Result
<R
, MethodError
<'tcx
>>,
306 let mut orig_values
= OriginalQueryValues
::default();
307 let param_env_and_self_ty
= self.infcx
.canonicalize_query(
308 &ParamEnvAnd { param_env: self.param_env, value: self_ty }
,
312 let steps
= if mode
== Mode
::MethodCall
{
313 self.tcx
.method_autoderef_steps(param_env_and_self_ty
)
315 self.infcx
.probe(|_
| {
316 // Mode::Path - the deref steps is "trivial". This turns
317 // our CanonicalQuery into a "trivial" QueryResponse. This
318 // is a bit inefficient, but I don't think that writing
319 // special handling for this "trivial case" is a good idea.
321 let infcx
= &self.infcx
;
322 let (ParamEnvAnd { param_env: _, value: self_ty }
, canonical_inference_vars
) =
323 infcx
.instantiate_canonical_with_fresh_inference_vars(
325 ¶m_env_and_self_ty
,
328 "probe_op: Mode::Path, param_env_and_self_ty={:?} self_ty={:?}",
329 param_env_and_self_ty
, self_ty
331 MethodAutoderefStepsResult
{
332 steps
: Lrc
::new(vec
![CandidateStep
{
333 self_ty
: self.make_query_response_ignoring_pending_obligations(
334 canonical_inference_vars
,
338 from_unsafe_deref
: false,
342 reached_recursion_limit
: false,
347 // If our autoderef loop had reached the recursion limit,
348 // report an overflow error, but continue going on with
349 // the truncated autoderef list.
350 if steps
.reached_recursion_limit
{
355 .unwrap_or_else(|| span_bug
!(span
, "reached the recursion limit in 0 steps?"))
358 .probe_instantiate_query_response(span
, &orig_values
, ty
)
359 .unwrap_or_else(|_
| span_bug
!(span
, "instantiating {:?} failed?", ty
));
360 autoderef
::report_autoderef_recursion_limit_error(self.tcx
, span
, ty
.value
);
364 // If we encountered an `_` type or an error type during autoderef, this is
366 if let Some(bad_ty
) = &steps
.opt_bad_ty
{
368 // Ambiguity was encountered during a suggestion. Just keep going.
369 debug
!("ProbeContext: encountered ambiguity in suggestion");
370 } else if bad_ty
.reached_raw_pointer
&& !self.tcx
.features().arbitrary_self_types
{
371 // this case used to be allowed by the compiler,
372 // so we do a future-compat lint here for the 2015 edition
373 // (see https://github.com/rust-lang/rust/issues/46906)
374 if self.tcx
.sess
.rust_2018() {
379 "the type of this value must be known \
380 to call a method on a raw pointer on it"
384 self.tcx
.struct_span_lint_hir(
385 lint
::builtin
::TYVAR_BEHIND_RAW_POINTER
,
388 |lint
| lint
.build("type annotations needed").emit(),
392 // Encountered a real ambiguity, so abort the lookup. If `ty` is not
393 // an `Err`, report the right "type annotations needed" error pointing
397 .probe_instantiate_query_response(span
, &orig_values
, ty
)
398 .unwrap_or_else(|_
| span_bug
!(span
, "instantiating {:?} failed?", ty
));
399 let ty
= self.structurally_resolved_type(span
, ty
.value
);
400 assert_eq
!(ty
, self.tcx
.types
.err
);
401 return Err(MethodError
::NoMatch(NoMatchData
::new(
411 debug
!("ProbeContext: steps for self_ty={:?} are {:?}", self_ty
, steps
);
413 // this creates one big transaction so that all type variables etc
414 // that we create during the probe process are removed later
416 let mut probe_cx
= ProbeContext
::new(
427 probe_cx
.assemble_inherent_candidates();
429 ProbeScope
::TraitsInScope
=> {
430 probe_cx
.assemble_extension_candidates_for_traits_in_scope(scope_expr_id
)?
432 ProbeScope
::AllTraits
=> probe_cx
.assemble_extension_candidates_for_all_traits()?
,
439 pub fn provide(providers
: &mut ty
::query
::Providers
<'_
>) {
440 providers
.method_autoderef_steps
= method_autoderef_steps
;
443 fn method_autoderef_steps
<'tcx
>(
445 goal
: CanonicalTyGoal
<'tcx
>,
446 ) -> MethodAutoderefStepsResult
<'tcx
> {
447 debug
!("method_autoderef_steps({:?})", goal
);
449 tcx
.infer_ctxt().enter_with_canonical(DUMMY_SP
, &goal
, |ref infcx
, goal
, inference_vars
| {
450 let ParamEnvAnd { param_env, value: self_ty }
= goal
;
452 let mut autoderef
= Autoderef
::new(infcx
, param_env
, hir
::DUMMY_HIR_ID
, DUMMY_SP
, self_ty
)
453 .include_raw_pointers()
455 let mut reached_raw_pointer
= false;
456 let mut steps
: Vec
<_
> = autoderef
459 let step
= CandidateStep
{
460 self_ty
: infcx
.make_query_response_ignoring_pending_obligations(
461 inference_vars
.clone(),
465 from_unsafe_deref
: reached_raw_pointer
,
468 if let ty
::RawPtr(_
) = ty
.kind
{
469 // all the subsequent steps will be from_unsafe_deref
470 reached_raw_pointer
= true;
476 let final_ty
= autoderef
.maybe_ambiguous_final_ty();
477 let opt_bad_ty
= match final_ty
.kind
{
478 ty
::Infer(ty
::TyVar(_
)) | ty
::Error
=> Some(MethodAutoderefBadTy
{
481 .make_query_response_ignoring_pending_obligations(inference_vars
, final_ty
),
483 ty
::Array(elem_ty
, _
) => {
484 let dereferences
= steps
.len() - 1;
486 steps
.push(CandidateStep
{
487 self_ty
: infcx
.make_query_response_ignoring_pending_obligations(
489 infcx
.tcx
.mk_slice(elem_ty
),
491 autoderefs
: dereferences
,
492 // this could be from an unsafe deref if we had
493 // a *mut/const [T; N]
494 from_unsafe_deref
: reached_raw_pointer
,
503 debug
!("method_autoderef_steps: steps={:?} opt_bad_ty={:?}", steps
, opt_bad_ty
);
505 MethodAutoderefStepsResult
{
506 steps
: Lrc
::new(steps
),
507 opt_bad_ty
: opt_bad_ty
.map(Lrc
::new
),
508 reached_recursion_limit
: autoderef
.reached_recursion_limit(),
513 impl<'a
, 'tcx
> ProbeContext
<'a
, 'tcx
> {
515 fcx
: &'a FnCtxt
<'a
, 'tcx
>,
518 method_name
: Option
<ast
::Ident
>,
519 return_type
: Option
<Ty
<'tcx
>>,
520 orig_steps_var_values
: OriginalQueryValues
<'tcx
>,
521 steps
: Lrc
<Vec
<CandidateStep
<'tcx
>>>,
522 is_suggestion
: IsSuggestion
,
523 ) -> ProbeContext
<'a
, 'tcx
> {
530 inherent_candidates
: Vec
::new(),
531 extension_candidates
: Vec
::new(),
532 impl_dups
: FxHashSet
::default(),
533 orig_steps_var_values
,
535 static_candidates
: Vec
::new(),
536 allow_similar_names
: false,
537 private_candidate
: None
,
538 unsatisfied_predicates
: Vec
::new(),
543 fn reset(&mut self) {
544 self.inherent_candidates
.clear();
545 self.extension_candidates
.clear();
546 self.impl_dups
.clear();
547 self.static_candidates
.clear();
548 self.private_candidate
= None
;
551 ///////////////////////////////////////////////////////////////////////////
552 // CANDIDATE ASSEMBLY
554 fn push_candidate(&mut self, candidate
: Candidate
<'tcx
>, is_inherent
: bool
) {
555 let is_accessible
= if let Some(name
) = self.method_name
{
556 let item
= candidate
.item
;
558 self.tcx
.adjust_ident_and_get_scope(name
, item
.container
.id(), self.body_id
).1;
559 item
.vis
.is_accessible_from(def_scope
, self.tcx
)
565 self.inherent_candidates
.push(candidate
);
567 self.extension_candidates
.push(candidate
);
569 } else if self.private_candidate
.is_none() {
570 self.private_candidate
= Some((candidate
.item
.def_kind(), candidate
.item
.def_id
));
574 fn assemble_inherent_candidates(&mut self) {
575 let steps
= Lrc
::clone(&self.steps
);
576 for step
in steps
.iter() {
577 self.assemble_probe(&step
.self_ty
);
581 fn assemble_probe(&mut self, self_ty
: &Canonical
<'tcx
, QueryResponse
<'tcx
, Ty
<'tcx
>>>) {
582 debug
!("assemble_probe: self_ty={:?}", self_ty
);
583 let lang_items
= self.tcx
.lang_items();
585 match self_ty
.value
.value
.kind
{
586 ty
::Dynamic(ref data
, ..) => {
587 if let Some(p
) = data
.principal() {
588 // Subtle: we can't use `instantiate_query_response` here: using it will
589 // commit to all of the type equalities assumed by inference going through
590 // autoderef (see the `method-probe-no-guessing` test).
592 // However, in this code, it is OK if we end up with an object type that is
593 // "more general" than the object type that we are evaluating. For *every*
594 // object type `MY_OBJECT`, a function call that goes through a trait-ref
595 // of the form `<MY_OBJECT as SuperTraitOf(MY_OBJECT)>::func` is a valid
596 // `ObjectCandidate`, and it should be discoverable "exactly" through one
597 // of the iterations in the autoderef loop, so there is no problem with it
598 // being discoverable in another one of these iterations.
600 // Using `instantiate_canonical_with_fresh_inference_vars` on our
601 // `Canonical<QueryResponse<Ty<'tcx>>>` and then *throwing away* the
602 // `CanonicalVarValues` will exactly give us such a generalization - it
603 // will still match the original object type, but it won't pollute our
604 // type variables in any form, so just do that!
605 let (QueryResponse { value: generalized_self_ty, .. }
, _ignored_var_values
) =
607 .instantiate_canonical_with_fresh_inference_vars(self.span
, &self_ty
);
609 self.assemble_inherent_candidates_from_object(generalized_self_ty
);
610 self.assemble_inherent_impl_candidates_for_type(p
.def_id());
614 self.assemble_inherent_impl_candidates_for_type(def
.did
);
616 ty
::Foreign(did
) => {
617 self.assemble_inherent_impl_candidates_for_type(did
);
620 self.assemble_inherent_candidates_from_param(p
);
623 let lang_def_id
= lang_items
.bool_impl();
624 self.assemble_inherent_impl_for_primitive(lang_def_id
);
627 let lang_def_id
= lang_items
.char_impl();
628 self.assemble_inherent_impl_for_primitive(lang_def_id
);
631 let lang_def_id
= lang_items
.str_impl();
632 self.assemble_inherent_impl_for_primitive(lang_def_id
);
634 let lang_def_id
= lang_items
.str_alloc_impl();
635 self.assemble_inherent_impl_for_primitive(lang_def_id
);
638 for &lang_def_id
in &[
639 lang_items
.slice_impl(),
640 lang_items
.slice_u8_impl(),
641 lang_items
.slice_alloc_impl(),
642 lang_items
.slice_u8_alloc_impl(),
644 self.assemble_inherent_impl_for_primitive(lang_def_id
);
647 ty
::RawPtr(ty
::TypeAndMut { ty: _, mutbl }
) => {
648 let lang_def_id
= match mutbl
{
649 hir
::Mutability
::Not
=> lang_items
.const_ptr_impl(),
650 hir
::Mutability
::Mut
=> lang_items
.mut_ptr_impl(),
652 self.assemble_inherent_impl_for_primitive(lang_def_id
);
655 let lang_def_id
= match i
{
656 ast
::IntTy
::I8
=> lang_items
.i8_impl(),
657 ast
::IntTy
::I16
=> lang_items
.i16_impl(),
658 ast
::IntTy
::I32
=> lang_items
.i32_impl(),
659 ast
::IntTy
::I64
=> lang_items
.i64_impl(),
660 ast
::IntTy
::I128
=> lang_items
.i128_impl(),
661 ast
::IntTy
::Isize
=> lang_items
.isize_impl(),
663 self.assemble_inherent_impl_for_primitive(lang_def_id
);
666 let lang_def_id
= match i
{
667 ast
::UintTy
::U8
=> lang_items
.u8_impl(),
668 ast
::UintTy
::U16
=> lang_items
.u16_impl(),
669 ast
::UintTy
::U32
=> lang_items
.u32_impl(),
670 ast
::UintTy
::U64
=> lang_items
.u64_impl(),
671 ast
::UintTy
::U128
=> lang_items
.u128_impl(),
672 ast
::UintTy
::Usize
=> lang_items
.usize_impl(),
674 self.assemble_inherent_impl_for_primitive(lang_def_id
);
677 let (lang_def_id1
, lang_def_id2
) = match f
{
678 ast
::FloatTy
::F32
=> (lang_items
.f32_impl(), lang_items
.f32_runtime_impl()),
679 ast
::FloatTy
::F64
=> (lang_items
.f64_impl(), lang_items
.f64_runtime_impl()),
681 self.assemble_inherent_impl_for_primitive(lang_def_id1
);
682 self.assemble_inherent_impl_for_primitive(lang_def_id2
);
688 fn assemble_inherent_impl_for_primitive(&mut self, lang_def_id
: Option
<DefId
>) {
689 if let Some(impl_def_id
) = lang_def_id
{
690 self.assemble_inherent_impl_probe(impl_def_id
);
694 fn assemble_inherent_impl_candidates_for_type(&mut self, def_id
: DefId
) {
695 let impl_def_ids
= self.tcx
.at(self.span
).inherent_impls(def_id
);
696 for &impl_def_id
in impl_def_ids
.iter() {
697 self.assemble_inherent_impl_probe(impl_def_id
);
701 fn assemble_inherent_impl_probe(&mut self, impl_def_id
: DefId
) {
702 if !self.impl_dups
.insert(impl_def_id
) {
703 return; // already visited
706 debug
!("assemble_inherent_impl_probe {:?}", impl_def_id
);
708 for item
in self.impl_or_trait_item(impl_def_id
) {
709 if !self.has_applicable_self(&item
) {
710 // No receiver declared. Not a candidate.
711 self.record_static_candidate(ImplSource(impl_def_id
));
715 let (impl_ty
, impl_substs
) = self.impl_ty_and_substs(impl_def_id
);
716 let impl_ty
= impl_ty
.subst(self.tcx
, impl_substs
);
718 // Determine the receiver type that the method itself expects.
719 let xform_tys
= self.xform_self_ty(&item
, impl_ty
, impl_substs
);
721 // We can't use normalize_associated_types_in as it will pollute the
722 // fcx's fulfillment context after this probe is over.
723 let cause
= traits
::ObligationCause
::misc(self.span
, self.body_id
);
724 let selcx
= &mut traits
::SelectionContext
::new(self.fcx
);
725 let traits
::Normalized { value: (xform_self_ty, xform_ret_ty), obligations }
=
726 traits
::normalize(selcx
, self.param_env
, cause
, &xform_tys
);
728 "assemble_inherent_impl_probe: xform_self_ty = {:?}/{:?}",
729 xform_self_ty
, xform_ret_ty
737 kind
: InherentImplCandidate(impl_substs
, obligations
),
738 import_ids
: smallvec
![],
745 fn assemble_inherent_candidates_from_object(&mut self, self_ty
: Ty
<'tcx
>) {
746 debug
!("assemble_inherent_candidates_from_object(self_ty={:?})", self_ty
);
748 let principal
= match self_ty
.kind
{
749 ty
::Dynamic(ref data
, ..) => Some(data
),
752 .and_then(|data
| data
.principal())
756 "non-object {:?} in assemble_inherent_candidates_from_object",
761 // It is illegal to invoke a method on a trait instance that
762 // refers to the `Self` type. An error will be reported by
763 // `enforce_object_limitations()` if the method refers to the
764 // `Self` type anywhere other than the receiver. Here, we use
765 // a substitution that replaces `Self` with the object type
766 // itself. Hence, a `&self` method will wind up with an
767 // argument type like `&Trait`.
768 let trait_ref
= principal
.with_self_ty(self.tcx
, self_ty
);
769 self.elaborate_bounds(iter
::once(trait_ref
), |this
, new_trait_ref
, item
| {
770 let new_trait_ref
= this
.erase_late_bound_regions(&new_trait_ref
);
772 let (xform_self_ty
, xform_ret_ty
) =
773 this
.xform_self_ty(&item
, new_trait_ref
.self_ty(), new_trait_ref
.substs
);
779 kind
: ObjectCandidate
,
780 import_ids
: smallvec
![],
787 fn assemble_inherent_candidates_from_param(&mut self, param_ty
: ty
::ParamTy
) {
788 // FIXME: do we want to commit to this behavior for param bounds?
790 let bounds
= self.param_env
.caller_bounds
.iter().filter_map(|predicate
| match *predicate
{
791 ty
::Predicate
::Trait(ref trait_predicate
, _
) => {
792 match trait_predicate
.skip_binder().trait_ref
.self_ty().kind
{
793 ty
::Param(ref p
) if *p
== param_ty
=> Some(trait_predicate
.to_poly_trait_ref()),
797 ty
::Predicate
::Subtype(..)
798 | ty
::Predicate
::Projection(..)
799 | ty
::Predicate
::RegionOutlives(..)
800 | ty
::Predicate
::WellFormed(..)
801 | ty
::Predicate
::ObjectSafe(..)
802 | ty
::Predicate
::ClosureKind(..)
803 | ty
::Predicate
::TypeOutlives(..)
804 | ty
::Predicate
::ConstEvaluatable(..) => None
,
807 self.elaborate_bounds(bounds
, |this
, poly_trait_ref
, item
| {
808 let trait_ref
= this
.erase_late_bound_regions(&poly_trait_ref
);
810 let (xform_self_ty
, xform_ret_ty
) =
811 this
.xform_self_ty(&item
, trait_ref
.self_ty(), trait_ref
.substs
);
813 // Because this trait derives from a where-clause, it
814 // should not contain any inference variables or other
815 // artifacts. This means it is safe to put into the
816 // `WhereClauseCandidate` and (eventually) into the
817 // `WhereClausePick`.
818 assert
!(!trait_ref
.substs
.needs_infer());
825 kind
: WhereClauseCandidate(poly_trait_ref
),
826 import_ids
: smallvec
![],
833 // Do a search through a list of bounds, using a callback to actually
834 // create the candidates.
835 fn elaborate_bounds
<F
>(
837 bounds
: impl Iterator
<Item
= ty
::PolyTraitRef
<'tcx
>>,
840 F
: for<'b
> FnMut(&mut ProbeContext
<'b
, 'tcx
>, ty
::PolyTraitRef
<'tcx
>, ty
::AssocItem
),
843 for bound_trait_ref
in traits
::transitive_bounds(tcx
, bounds
) {
844 debug
!("elaborate_bounds(bound_trait_ref={:?})", bound_trait_ref
);
845 for item
in self.impl_or_trait_item(bound_trait_ref
.def_id()) {
846 if !self.has_applicable_self(&item
) {
847 self.record_static_candidate(TraitSource(bound_trait_ref
.def_id()));
849 mk_cand(self, bound_trait_ref
, item
);
855 fn assemble_extension_candidates_for_traits_in_scope(
857 expr_hir_id
: hir
::HirId
,
858 ) -> Result
<(), MethodError
<'tcx
>> {
859 if expr_hir_id
== hir
::DUMMY_HIR_ID
{
862 let mut duplicates
= FxHashSet
::default();
863 let opt_applicable_traits
= self.tcx
.in_scope_traits(expr_hir_id
);
864 if let Some(applicable_traits
) = opt_applicable_traits
{
865 for trait_candidate
in applicable_traits
.iter() {
866 let trait_did
= trait_candidate
.def_id
;
867 if duplicates
.insert(trait_did
) {
868 let result
= self.assemble_extension_candidates_for_trait(
869 &trait_candidate
.import_ids
,
879 fn assemble_extension_candidates_for_all_traits(&mut self) -> Result
<(), MethodError
<'tcx
>> {
880 let mut duplicates
= FxHashSet
::default();
881 for trait_info
in suggest
::all_traits(self.tcx
) {
882 if duplicates
.insert(trait_info
.def_id
) {
883 self.assemble_extension_candidates_for_trait(&smallvec
![], trait_info
.def_id
)?
;
889 pub fn matches_return_type(
891 method
: &ty
::AssocItem
,
892 self_ty
: Option
<Ty
<'tcx
>>,
896 ty
::AssocKind
::Method
=> {
897 let fty
= self.tcx
.fn_sig(method
.def_id
);
899 let substs
= self.fresh_substs_for_item(self.span
, method
.def_id
);
900 let fty
= fty
.subst(self.tcx
, substs
);
902 self.replace_bound_vars_with_fresh_vars(self.span
, infer
::FnCall
, &fty
);
904 if let Some(self_ty
) = self_ty
{
906 .at(&ObligationCause
::dummy(), self.param_env
)
907 .sup(fty
.inputs()[0], self_ty
)
913 self.can_sub(self.param_env
, fty
.output(), expected
).is_ok()
920 fn assemble_extension_candidates_for_trait(
922 import_ids
: &SmallVec
<[hir
::HirId
; 1]>,
924 ) -> Result
<(), MethodError
<'tcx
>> {
925 debug
!("assemble_extension_candidates_for_trait(trait_def_id={:?})", trait_def_id
);
926 let trait_substs
= self.fresh_item_substs(trait_def_id
);
927 let trait_ref
= ty
::TraitRef
::new(trait_def_id
, trait_substs
);
929 if self.tcx
.is_trait_alias(trait_def_id
) {
930 // For trait aliases, assume all super-traits are relevant.
931 let bounds
= iter
::once(trait_ref
.to_poly_trait_ref());
932 self.elaborate_bounds(bounds
, |this
, new_trait_ref
, item
| {
933 let new_trait_ref
= this
.erase_late_bound_regions(&new_trait_ref
);
935 let (xform_self_ty
, xform_ret_ty
) =
936 this
.xform_self_ty(&item
, new_trait_ref
.self_ty(), new_trait_ref
.substs
);
942 import_ids
: import_ids
.clone(),
943 kind
: TraitCandidate(new_trait_ref
),
949 debug_assert
!(self.tcx
.is_trait(trait_def_id
));
950 for item
in self.impl_or_trait_item(trait_def_id
) {
951 // Check whether `trait_def_id` defines a method with suitable name.
952 if !self.has_applicable_self(&item
) {
953 debug
!("method has inapplicable self");
954 self.record_static_candidate(TraitSource(trait_def_id
));
958 let (xform_self_ty
, xform_ret_ty
) =
959 self.xform_self_ty(&item
, trait_ref
.self_ty(), trait_substs
);
965 import_ids
: import_ids
.clone(),
966 kind
: TraitCandidate(trait_ref
),
975 fn candidate_method_names(&self) -> Vec
<ast
::Ident
> {
976 let mut set
= FxHashSet
::default();
977 let mut names
: Vec
<_
> = self
980 .chain(&self.extension_candidates
)
981 .filter(|candidate
| {
982 if let Some(return_ty
) = self.return_type
{
983 self.matches_return_type(&candidate
.item
, None
, return_ty
)
988 .map(|candidate
| candidate
.item
.ident
)
989 .filter(|&name
| set
.insert(name
))
992 // Sort them by the name so we have a stable result.
993 names
.sort_by_cached_key(|n
| n
.as_str());
997 ///////////////////////////////////////////////////////////////////////////
1000 fn pick(mut self) -> PickResult
<'tcx
> {
1001 assert
!(self.method_name
.is_some());
1003 if let Some(r
) = self.pick_core() {
1007 debug
!("pick: actual search failed, assemble diagnostics");
1009 let static_candidates
= mem
::take(&mut self.static_candidates
);
1010 let private_candidate
= self.private_candidate
.take();
1011 let unsatisfied_predicates
= mem
::take(&mut self.unsatisfied_predicates
);
1013 // things failed, so lets look at all traits, for diagnostic purposes now:
1016 let span
= self.span
;
1019 self.assemble_extension_candidates_for_all_traits()?
;
1021 let out_of_scope_traits
= match self.pick_core() {
1022 Some(Ok(p
)) => vec
![p
.item
.container
.id()],
1023 //Some(Ok(p)) => p.iter().map(|p| p.item.container().id()).collect(),
1024 Some(Err(MethodError
::Ambiguity(v
))) => v
1026 .map(|source
| match source
{
1027 TraitSource(id
) => id
,
1028 ImplSource(impl_id
) => match tcx
.trait_id_of_impl(impl_id
) {
1030 None
=> span_bug
!(span
, "found inherent method when looking at traits"),
1034 Some(Err(MethodError
::NoMatch(NoMatchData
{
1035 out_of_scope_traits
: others
, ..
1037 assert
!(others
.is_empty());
1043 if let Some((kind
, def_id
)) = private_candidate
{
1044 return Err(MethodError
::PrivateMatch(kind
, def_id
, out_of_scope_traits
));
1046 let lev_candidate
= self.probe_for_lev_candidate()?
;
1048 Err(MethodError
::NoMatch(NoMatchData
::new(
1050 unsatisfied_predicates
,
1051 out_of_scope_traits
,
1057 fn pick_core(&mut self) -> Option
<PickResult
<'tcx
>> {
1058 let steps
= self.steps
.clone();
1060 // find the first step that works
1064 debug
!("pick_core: step={:?}", step
);
1065 // skip types that are from a type error or that would require dereferencing
1067 !step
.self_ty
.references_error() && !step
.from_unsafe_deref
1070 let InferOk { value: self_ty, obligations: _ }
= self
1072 .probe_instantiate_query_response(
1074 &self.orig_steps_var_values
,
1077 .unwrap_or_else(|_
| {
1078 span_bug
!(self.span
, "{:?} was applicable but now isn't?", step
.self_ty
)
1080 self.pick_by_value_method(step
, self_ty
).or_else(|| {
1081 self.pick_autorefd_method(step
, self_ty
, hir
::Mutability
::Not
)
1082 .or_else(|| self.pick_autorefd_method(step
, self_ty
, hir
::Mutability
::Mut
))
1088 fn pick_by_value_method(
1090 step
: &CandidateStep
<'tcx
>,
1092 ) -> Option
<PickResult
<'tcx
>> {
1093 //! For each type `T` in the step list, this attempts to find a
1094 //! method where the (transformed) self type is exactly `T`. We
1095 //! do however do one transformation on the adjustment: if we
1096 //! are passing a region pointer in, we will potentially
1097 //! *reborrow* it to a shorter lifetime. This allows us to
1098 //! transparently pass `&mut` pointers, in particular, without
1099 //! consuming them for their entire lifetime.
1105 self.pick_method(self_ty
).map(|r
| {
1107 pick
.autoderefs
= step
.autoderefs
;
1109 // Insert a `&*` or `&mut *` if this is a reference type:
1110 if let ty
::Ref(_
, _
, mutbl
) = step
.self_ty
.value
.value
.kind
{
1111 pick
.autoderefs
+= 1;
1112 pick
.autoref
= Some(mutbl
);
1120 fn pick_autorefd_method(
1122 step
: &CandidateStep
<'tcx
>,
1124 mutbl
: hir
::Mutability
,
1125 ) -> Option
<PickResult
<'tcx
>> {
1128 // In general, during probing we erase regions. See
1129 // `impl_self_ty()` for an explanation.
1130 let region
= tcx
.lifetimes
.re_erased
;
1132 let autoref_ty
= tcx
.mk_ref(region
, ty
::TypeAndMut { ty: self_ty, mutbl }
);
1133 self.pick_method(autoref_ty
).map(|r
| {
1135 pick
.autoderefs
= step
.autoderefs
;
1136 pick
.autoref
= Some(mutbl
);
1137 pick
.unsize
= step
.unsize
.then_some(self_ty
);
1143 fn pick_method(&mut self, self_ty
: Ty
<'tcx
>) -> Option
<PickResult
<'tcx
>> {
1144 debug
!("pick_method(self_ty={})", self.ty_to_string(self_ty
));
1146 let mut possibly_unsatisfied_predicates
= Vec
::new();
1147 let mut unstable_candidates
= Vec
::new();
1149 for (kind
, candidates
) in
1150 &[("inherent", &self.inherent_candidates
), ("extension", &self.extension_candidates
)]
1152 debug
!("searching {} candidates", kind
);
1153 let res
= self.consider_candidates(
1156 &mut possibly_unsatisfied_predicates
,
1157 Some(&mut unstable_candidates
),
1159 if let Some(pick
) = res
{
1160 if !self.is_suggestion
.0 && !unstable_candidates
.is_empty() {
1161 if let Ok(p
) = &pick
{
1162 // Emit a lint if there are unstable candidates alongside the stable ones.
1164 // We suppress warning if we're picking the method only because it is a
1166 self.emit_unstable_name_collision_hint(p
, &unstable_candidates
);
1173 debug
!("searching unstable candidates");
1174 let res
= self.consider_candidates(
1176 unstable_candidates
.into_iter().map(|(c
, _
)| c
),
1177 &mut possibly_unsatisfied_predicates
,
1181 self.unsatisfied_predicates
.extend(possibly_unsatisfied_predicates
);
1186 fn consider_candidates
<'b
, ProbesIter
>(
1190 possibly_unsatisfied_predicates
: &mut Vec
<(
1191 ty
::Predicate
<'tcx
>,
1192 Option
<ty
::Predicate
<'tcx
>>,
1194 unstable_candidates
: Option
<&mut Vec
<(&'b Candidate
<'tcx
>, Symbol
)>>,
1195 ) -> Option
<PickResult
<'tcx
>>
1197 ProbesIter
: Iterator
<Item
= &'b Candidate
<'tcx
>> + Clone
,
1199 let mut applicable_candidates
: Vec
<_
> = probes
1202 (probe
, self.consider_probe(self_ty
, probe
, possibly_unsatisfied_predicates
))
1204 .filter(|&(_
, status
)| status
!= ProbeResult
::NoMatch
)
1207 debug
!("applicable_candidates: {:?}", applicable_candidates
);
1209 if applicable_candidates
.len() > 1 {
1210 if let Some(pick
) = self.collapse_candidates_to_trait_pick(&applicable_candidates
[..]) {
1211 return Some(Ok(pick
));
1215 if let Some(uc
) = unstable_candidates
{
1216 applicable_candidates
.retain(|&(p
, _
)| {
1217 if let stability
::EvalResult
::Deny { feature, .. }
=
1218 self.tcx
.eval_stability(p
.item
.def_id
, None
, self.span
)
1220 uc
.push((p
, feature
));
1227 if applicable_candidates
.len() > 1 {
1228 let sources
= probes
.map(|p
| self.candidate_source(p
, self_ty
)).collect();
1229 return Some(Err(MethodError
::Ambiguity(sources
)));
1232 applicable_candidates
.pop().map(|(probe
, status
)| {
1233 if status
== ProbeResult
::Match
{
1234 Ok(probe
.to_unadjusted_pick())
1236 Err(MethodError
::BadReturnType
)
1241 fn emit_unstable_name_collision_hint(
1243 stable_pick
: &Pick
<'_
>,
1244 unstable_candidates
: &[(&Candidate
<'tcx
>, Symbol
)],
1246 self.tcx
.struct_span_lint_hir(
1247 lint
::builtin
::UNSTABLE_NAME_COLLISIONS
,
1251 let mut diag
= lint
.build(
1252 "a method with this name may be added to the standard library in the future",
1254 // FIXME: This should be a `span_suggestion` instead of `help`
1255 // However `self.span` only
1256 // highlights the method name, so we can't use it. Also consider reusing the code from
1257 // `report_method_error()`.
1259 "call with fully qualified syntax `{}(...)` to keep using the current method",
1260 self.tcx
.def_path_str(stable_pick
.item
.def_id
),
1263 if nightly_options
::is_nightly_build() {
1264 for (candidate
, feature
) in unstable_candidates
{
1266 "add `#![feature({})]` to the crate attributes to enable `{}`",
1268 self.tcx
.def_path_str(candidate
.item
.def_id
),
1278 fn select_trait_candidate(
1280 trait_ref
: ty
::TraitRef
<'tcx
>,
1281 ) -> traits
::SelectionResult
<'tcx
, traits
::Selection
<'tcx
>> {
1282 let cause
= traits
::ObligationCause
::misc(self.span
, self.body_id
);
1283 let predicate
= trait_ref
.to_poly_trait_ref().to_poly_trait_predicate();
1284 let obligation
= traits
::Obligation
::new(cause
, self.param_env
, predicate
);
1285 traits
::SelectionContext
::new(self).select(&obligation
)
1288 fn candidate_source(&self, candidate
: &Candidate
<'tcx
>, self_ty
: Ty
<'tcx
>) -> CandidateSource
{
1289 match candidate
.kind
{
1290 InherentImplCandidate(..) => ImplSource(candidate
.item
.container
.id()),
1291 ObjectCandidate
| WhereClauseCandidate(_
) => TraitSource(candidate
.item
.container
.id()),
1292 TraitCandidate(trait_ref
) => self.probe(|_
| {
1294 .at(&ObligationCause
::dummy(), self.param_env
)
1295 .sup(candidate
.xform_self_ty
, self_ty
);
1296 match self.select_trait_candidate(trait_ref
) {
1297 Ok(Some(traits
::Vtable
::VtableImpl(ref impl_data
))) => {
1298 // If only a single impl matches, make the error message point
1300 ImplSource(impl_data
.impl_def_id
)
1302 _
=> TraitSource(candidate
.item
.container
.id()),
1311 probe
: &Candidate
<'tcx
>,
1312 possibly_unsatisfied_predicates
: &mut Vec
<(
1313 ty
::Predicate
<'tcx
>,
1314 Option
<ty
::Predicate
<'tcx
>>,
1317 debug
!("consider_probe: self_ty={:?} probe={:?}", self_ty
, probe
);
1320 // First check that the self type can be related.
1321 let sub_obligations
= match self
1322 .at(&ObligationCause
::dummy(), self.param_env
)
1323 .sup(probe
.xform_self_ty
, self_ty
)
1325 Ok(InferOk { obligations, value: () }
) => obligations
,
1327 debug
!("--> cannot relate self-types");
1328 return ProbeResult
::NoMatch
;
1332 let mut result
= ProbeResult
::Match
;
1333 let selcx
= &mut traits
::SelectionContext
::new(self);
1334 let cause
= traits
::ObligationCause
::misc(self.span
, self.body_id
);
1336 // If so, impls may carry other conditions (e.g., where
1337 // clauses) that must be considered. Make sure that those
1338 // match as well (or at least may match, sometimes we
1339 // don't have enough information to fully evaluate).
1340 let candidate_obligations
: Vec
<_
> = match probe
.kind
{
1341 InherentImplCandidate(ref substs
, ref ref_obligations
) => {
1342 // Check whether the impl imposes obligations we have to worry about.
1343 let impl_def_id
= probe
.item
.container
.id();
1344 let impl_bounds
= self.tcx
.predicates_of(impl_def_id
);
1345 let impl_bounds
= impl_bounds
.instantiate(self.tcx
, substs
);
1346 let traits
::Normalized { value: impl_bounds, obligations: norm_obligations }
=
1347 traits
::normalize(selcx
, self.param_env
, cause
.clone(), &impl_bounds
);
1349 // Convert the bounds into obligations.
1350 let impl_obligations
=
1351 traits
::predicates_for_generics(cause
, self.param_env
, &impl_bounds
);
1353 debug
!("impl_obligations={:?}", impl_obligations
);
1356 .chain(norm_obligations
.into_iter())
1357 .chain(ref_obligations
.iter().cloned())
1361 ObjectCandidate
| WhereClauseCandidate(..) => {
1362 // These have no additional conditions to check.
1366 TraitCandidate(trait_ref
) => {
1367 let predicate
= trait_ref
.without_const().to_predicate();
1368 let obligation
= traits
::Obligation
::new(cause
, self.param_env
, predicate
);
1369 if !self.predicate_may_hold(&obligation
) {
1370 result
= ProbeResult
::NoMatch
;
1372 match self.select_trait_candidate(trait_ref
) {
1373 Err(_
) => return true,
1375 if !vtable
.borrow_nested_obligations().is_empty() =>
1377 for obligation
in vtable
.borrow_nested_obligations() {
1378 // Determine exactly which obligation wasn't met, so
1379 // that we can give more context in the error.
1380 if !self.predicate_may_hold(&obligation
) {
1381 let o
= self.resolve_vars_if_possible(obligation
);
1383 self.resolve_vars_if_possible(&predicate
);
1384 let p
= if predicate
== o
.predicate
{
1385 // Avoid "`MyStruct: Foo` which is required by
1386 // `MyStruct: Foo`" in E0599.
1391 possibly_unsatisfied_predicates
.push((o
.predicate
, p
));
1396 // Some nested subobligation of this predicate
1398 let predicate
= self.resolve_vars_if_possible(&predicate
);
1399 possibly_unsatisfied_predicates
.push((predicate
, None
));
1404 // This candidate's primary obligation doesn't even
1405 // select - don't bother registering anything in
1406 // `potentially_unsatisfied_predicates`.
1407 return ProbeResult
::NoMatch
;
1415 "consider_probe - candidate_obligations={:?} sub_obligations={:?}",
1416 candidate_obligations
, sub_obligations
1419 // Evaluate those obligations to see if they might possibly hold.
1420 for o
in candidate_obligations
.into_iter().chain(sub_obligations
) {
1421 let o
= self.resolve_vars_if_possible(&o
);
1422 if !self.predicate_may_hold(&o
) {
1423 result
= ProbeResult
::NoMatch
;
1424 possibly_unsatisfied_predicates
.push((o
.predicate
, None
));
1428 if let ProbeResult
::Match
= result
{
1429 if let (Some(return_ty
), Some(xform_ret_ty
)) =
1430 (self.return_type
, probe
.xform_ret_ty
)
1432 let xform_ret_ty
= self.resolve_vars_if_possible(&xform_ret_ty
);
1434 "comparing return_ty {:?} with xform ret ty {:?}",
1435 return_ty
, probe
.xform_ret_ty
1438 .at(&ObligationCause
::dummy(), self.param_env
)
1439 .sup(return_ty
, xform_ret_ty
)
1442 return ProbeResult
::BadReturnType
;
1451 /// Sometimes we get in a situation where we have multiple probes that are all impls of the
1452 /// same trait, but we don't know which impl to use. In this case, since in all cases the
1453 /// external interface of the method can be determined from the trait, it's ok not to decide.
1454 /// We can basically just collapse all of the probes for various impls into one where-clause
1455 /// probe. This will result in a pending obligation so when more type-info is available we can
1456 /// make the final decision.
1458 /// Example (`src/test/ui/method-two-trait-defer-resolution-1.rs`):
1461 /// trait Foo { ... }
1462 /// impl Foo for Vec<int> { ... }
1463 /// impl Foo for Vec<usize> { ... }
1466 /// Now imagine the receiver is `Vec<_>`. It doesn't really matter at this time which impl we
1467 /// use, so it's ok to just commit to "using the method from the trait Foo".
1468 fn collapse_candidates_to_trait_pick(
1470 probes
: &[(&Candidate
<'tcx
>, ProbeResult
)],
1471 ) -> Option
<Pick
<'tcx
>> {
1472 // Do all probes correspond to the same trait?
1473 let container
= probes
[0].0.item
.container
;
1474 if let ty
::ImplContainer(_
) = container
{
1477 if probes
[1..].iter().any(|&(p
, _
)| p
.item
.container
!= container
) {
1481 // FIXME: check the return type here somehow.
1482 // If so, just use this trait and call it a day.
1484 item
: probes
[0].0.item
,
1486 import_ids
: probes
[0].0.import_ids
.clone(),
1493 /// Similarly to `probe_for_return_type`, this method attempts to find the best matching
1494 /// candidate method where the method name may have been misspelt. Similarly to other
1495 /// Levenshtein based suggestions, we provide at most one such suggestion.
1496 fn probe_for_lev_candidate(&mut self) -> Result
<Option
<ty
::AssocItem
>, MethodError
<'tcx
>> {
1497 debug
!("probing for method names similar to {:?}", self.method_name
);
1499 let steps
= self.steps
.clone();
1501 let mut pcx
= ProbeContext
::new(
1507 self.orig_steps_var_values
.clone(),
1511 pcx
.allow_similar_names
= true;
1512 pcx
.assemble_inherent_candidates();
1513 pcx
.assemble_extension_candidates_for_traits_in_scope(hir
::DUMMY_HIR_ID
)?
;
1515 let method_names
= pcx
.candidate_method_names();
1516 pcx
.allow_similar_names
= false;
1517 let applicable_close_candidates
: Vec
<ty
::AssocItem
> = method_names
1519 .filter_map(|&method_name
| {
1521 pcx
.method_name
= Some(method_name
);
1522 pcx
.assemble_inherent_candidates();
1523 pcx
.assemble_extension_candidates_for_traits_in_scope(hir
::DUMMY_HIR_ID
)
1525 pcx
.pick_core().and_then(|pick
| pick
.ok()).map(|pick
| pick
.item
)
1530 if applicable_close_candidates
.is_empty() {
1534 let names
= applicable_close_candidates
.iter().map(|cand
| &cand
.ident
.name
);
1535 find_best_match_for_name(names
, &self.method_name
.unwrap().as_str(), None
)
1538 Ok(applicable_close_candidates
1540 .find(|method
| method
.ident
.name
== best_name
))
1545 ///////////////////////////////////////////////////////////////////////////
1547 fn has_applicable_self(&self, item
: &ty
::AssocItem
) -> bool
{
1548 // "Fast track" -- check for usage of sugar when in method call
1551 // In Path mode (i.e., resolving a value like `T::next`), consider any
1552 // associated value (i.e., methods, constants) but not types.
1554 Mode
::MethodCall
=> item
.method_has_self_argument
,
1555 Mode
::Path
=> match item
.kind
{
1556 ty
::AssocKind
::OpaqueTy
| ty
::AssocKind
::Type
=> false,
1557 ty
::AssocKind
::Method
| ty
::AssocKind
::Const
=> true,
1560 // FIXME -- check for types that deref to `Self`,
1561 // like `Rc<Self>` and so on.
1563 // Note also that the current code will break if this type
1564 // includes any of the type parameters defined on the method
1565 // -- but this could be overcome.
1568 fn record_static_candidate(&mut self, source
: CandidateSource
) {
1569 self.static_candidates
.push(source
);
1574 item
: &ty
::AssocItem
,
1576 substs
: SubstsRef
<'tcx
>,
1577 ) -> (Ty
<'tcx
>, Option
<Ty
<'tcx
>>) {
1578 if item
.kind
== ty
::AssocKind
::Method
&& self.mode
== Mode
::MethodCall
{
1579 let sig
= self.xform_method_sig(item
.def_id
, substs
);
1580 (sig
.inputs()[0], Some(sig
.output()))
1586 fn xform_method_sig(&self, method
: DefId
, substs
: SubstsRef
<'tcx
>) -> ty
::FnSig
<'tcx
> {
1587 let fn_sig
= self.tcx
.fn_sig(method
);
1588 debug
!("xform_self_ty(fn_sig={:?}, substs={:?})", fn_sig
, substs
);
1590 assert
!(!substs
.has_escaping_bound_vars());
1592 // It is possible for type parameters or early-bound lifetimes
1593 // to appear in the signature of `self`. The substitutions we
1594 // are given do not include type/lifetime parameters for the
1595 // method yet. So create fresh variables here for those too,
1596 // if there are any.
1597 let generics
= self.tcx
.generics_of(method
);
1598 assert_eq
!(substs
.len(), generics
.parent_count
as usize);
1600 // Erase any late-bound regions from the method and substitute
1601 // in the values from the substitution.
1602 let xform_fn_sig
= self.erase_late_bound_regions(&fn_sig
);
1604 if generics
.params
.is_empty() {
1605 xform_fn_sig
.subst(self.tcx
, substs
)
1607 let substs
= InternalSubsts
::for_item(self.tcx
, method
, |param
, _
| {
1608 let i
= param
.index
as usize;
1609 if i
< substs
.len() {
1613 GenericParamDefKind
::Lifetime
=> {
1614 // In general, during probe we erase regions. See
1615 // `impl_self_ty()` for an explanation.
1616 self.tcx
.lifetimes
.re_erased
.into()
1618 GenericParamDefKind
::Type { .. }
| GenericParamDefKind
::Const
=> {
1619 self.var_for_def(self.span
, param
)
1624 xform_fn_sig
.subst(self.tcx
, substs
)
1628 /// Gets the type of an impl and generate substitutions with placeholders.
1629 fn impl_ty_and_substs(&self, impl_def_id
: DefId
) -> (Ty
<'tcx
>, SubstsRef
<'tcx
>) {
1630 (self.tcx
.type_of(impl_def_id
), self.fresh_item_substs(impl_def_id
))
1633 fn fresh_item_substs(&self, def_id
: DefId
) -> SubstsRef
<'tcx
> {
1634 InternalSubsts
::for_item(self.tcx
, def_id
, |param
, _
| match param
.kind
{
1635 GenericParamDefKind
::Lifetime
=> self.tcx
.lifetimes
.re_erased
.into(),
1636 GenericParamDefKind
::Type { .. }
=> self
1637 .next_ty_var(TypeVariableOrigin
{
1638 kind
: TypeVariableOriginKind
::SubstitutionPlaceholder
,
1639 span
: self.tcx
.def_span(def_id
),
1642 GenericParamDefKind
::Const { .. }
=> {
1643 let span
= self.tcx
.def_span(def_id
);
1644 let origin
= ConstVariableOrigin
{
1645 kind
: ConstVariableOriginKind
::SubstitutionPlaceholder
,
1648 self.next_const_var(self.tcx
.type_of(param
.def_id
), origin
).into()
1653 /// Replaces late-bound-regions bound by `value` with `'static` using
1654 /// `ty::erase_late_bound_regions`.
1656 /// This is only a reasonable thing to do during the *probe* phase, not the *confirm* phase, of
1657 /// method matching. It is reasonable during the probe phase because we don't consider region
1658 /// relationships at all. Therefore, we can just replace all the region variables with 'static
1659 /// rather than creating fresh region variables. This is nice for two reasons:
1661 /// 1. Because the numbers of the region variables would otherwise be fairly unique to this
1662 /// particular method call, it winds up creating fewer types overall, which helps for memory
1663 /// usage. (Admittedly, this is a rather small effect, though measurable.)
1665 /// 2. It makes it easier to deal with higher-ranked trait bounds, because we can replace any
1666 /// late-bound regions with 'static. Otherwise, if we were going to replace late-bound
1667 /// regions with actual region variables as is proper, we'd have to ensure that the same
1668 /// region got replaced with the same variable, which requires a bit more coordination
1669 /// and/or tracking the substitution and
1671 fn erase_late_bound_regions
<T
>(&self, value
: &ty
::Binder
<T
>) -> T
1673 T
: TypeFoldable
<'tcx
>,
1675 self.tcx
.erase_late_bound_regions(value
)
1678 /// Finds the method with the appropriate name (or return type, as the case may be). If
1679 /// `allow_similar_names` is set, find methods with close-matching names.
1680 fn impl_or_trait_item(&self, def_id
: DefId
) -> Vec
<ty
::AssocItem
> {
1681 if let Some(name
) = self.method_name
{
1682 if self.allow_similar_names
{
1683 let max_dist
= max(name
.as_str().len(), 3) / 3;
1685 .associated_items(def_id
)
1686 .in_definition_order()
1688 let dist
= lev_distance(&*name
.as_str(), &x
.ident
.as_str());
1689 x
.kind
.namespace() == Namespace
::ValueNS
&& dist
> 0 && dist
<= max_dist
1695 .associated_item(def_id
, name
, Namespace
::ValueNS
)
1696 .map_or(Vec
::new(), |x
| vec
![x
])
1699 self.tcx
.associated_items(def_id
).in_definition_order().copied().collect()
1704 impl<'tcx
> Candidate
<'tcx
> {
1705 fn to_unadjusted_pick(&self) -> Pick
<'tcx
> {
1708 kind
: match self.kind
{
1709 InherentImplCandidate(..) => InherentImplPick
,
1710 ObjectCandidate
=> ObjectPick
,
1711 TraitCandidate(_
) => TraitPick
,
1712 WhereClauseCandidate(ref trait_ref
) => {
1713 // Only trait derived from where-clauses should
1714 // appear here, so they should not contain any
1715 // inference variables or other artifacts. This
1716 // means they are safe to put into the
1717 // `WhereClausePick`.
1719 !trait_ref
.skip_binder().substs
.needs_infer()
1720 && !trait_ref
.skip_binder().substs
.has_placeholders()
1723 WhereClausePick(*trait_ref
)
1726 import_ids
: self.import_ids
.clone(),