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.
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.
11 //! Method lookup: the secret sauce of Rust. See `README.md`.
16 use middle::privacy::{AllPublic, DependsOn, LastPrivate, LastMod};
19 use middle::ty::{self, ToPredicate, ToPolyTraitRef, TraitRef};
22 use syntax::ast::DefId;
24 use syntax::codemap::Span;
26 pub use self::MethodError::*;
27 pub use self::CandidateSource::*;
29 pub use self::suggest::{report_error, AllTraitsVec};
35 pub enum MethodError<'tcx> {
36 // Did not find an applicable method, but we did find various near-misses that may work.
37 NoMatch(NoMatchData<'tcx>),
39 // Multiple methods might apply.
40 Ambiguity(Vec<CandidateSource>),
42 // Using a `Fn`/`FnMut`/etc method on a raw closure type before we have inferred its kind.
43 ClosureAmbiguity(/* DefId of fn trait */ ast::DefId),
46 // Contains a list of static methods that may apply, a list of unsatisfied trait predicates which
47 // could lead to matches if satisfied, and a list of not-in-scope traits which may work.
48 pub struct NoMatchData<'tcx> {
49 pub static_candidates: Vec<CandidateSource>,
50 pub unsatisfied_predicates: Vec<TraitRef<'tcx>>,
51 pub out_of_scope_traits: Vec<ast::DefId>,
55 impl<'tcx> NoMatchData<'tcx> {
56 pub fn new(static_candidates: Vec<CandidateSource>,
57 unsatisfied_predicates: Vec<TraitRef<'tcx>>,
58 out_of_scope_traits: Vec<ast::DefId>,
59 mode: probe::Mode) -> Self {
61 static_candidates: static_candidates,
62 unsatisfied_predicates: unsatisfied_predicates,
63 out_of_scope_traits: out_of_scope_traits,
69 // A pared down enum describing just the places from which a method
70 // candidate can arise. Used for error reporting only.
71 #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
72 pub enum CandidateSource {
73 ImplSource(ast::DefId),
74 TraitSource(/* trait id */ ast::DefId),
77 /// Determines whether the type `self_ty` supports a method name `method_name` or not.
78 pub fn exists<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
80 method_name: ast::Name,
81 self_ty: ty::Ty<'tcx>,
82 call_expr_id: ast::NodeId)
85 let mode = probe::Mode::MethodCall;
86 match probe::probe(fcx, span, mode, method_name, self_ty, call_expr_id) {
88 Err(NoMatch(..)) => false,
89 Err(Ambiguity(..)) => true,
90 Err(ClosureAmbiguity(..)) => true,
94 /// Performs method lookup. If lookup is successful, it will return the callee and store an
95 /// appropriate adjustment for the self-expr. In some cases it may report an error (e.g., invoking
96 /// the `drop` method).
100 /// Given a method call like `foo.bar::<T1,...Tn>(...)`:
102 /// * `fcx`: the surrounding `FnCtxt` (!)
103 /// * `span`: the span for the method call
104 /// * `method_name`: the name of the method being called (`bar`)
105 /// * `self_ty`: the (unadjusted) type of the self expression (`foo`)
106 /// * `supplied_method_types`: the explicit method type parameters, if any (`T1..Tn`)
107 /// * `self_expr`: the self expression (`foo`)
108 pub fn lookup<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
110 method_name: ast::Name,
111 self_ty: ty::Ty<'tcx>,
112 supplied_method_types: Vec<ty::Ty<'tcx>>,
113 call_expr: &'tcx ast::Expr,
114 self_expr: &'tcx ast::Expr)
115 -> Result<ty::MethodCallee<'tcx>, MethodError<'tcx>>
117 debug!("lookup(method_name={}, self_ty={:?}, call_expr={:?}, self_expr={:?})",
123 let mode = probe::Mode::MethodCall;
124 let self_ty = fcx.infcx().resolve_type_vars_if_possible(&self_ty);
125 let pick = try!(probe::probe(fcx, span, mode, method_name, self_ty, call_expr.id));
126 Ok(confirm::confirm(fcx, span, self_expr, call_expr, self_ty, pick, supplied_method_types))
129 pub fn lookup_in_trait<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
131 self_expr: Option<&ast::Expr>,
134 self_ty: ty::Ty<'tcx>,
135 opt_input_types: Option<Vec<ty::Ty<'tcx>>>)
136 -> Option<ty::MethodCallee<'tcx>>
138 lookup_in_trait_adjusted(fcx, span, self_expr, m_name, trait_def_id,
139 0, false, self_ty, opt_input_types)
142 /// `lookup_in_trait_adjusted` is used for overloaded operators. It does a very narrow slice of
143 /// what the normal probe/confirm path does. In particular, it doesn't really do any probing: it
144 /// simply constructs an obligation for a particular trait with the given self-type and checks
145 /// whether that trait is implemented.
147 /// FIXME(#18741) -- It seems likely that we can consolidate some of this code with the other
148 /// method-lookup code. In particular, autoderef on index is basically identical to autoderef with
149 /// normal probes, except that the test also looks for built-in indexing. Also, the second half of
150 /// this method is basically the same as confirmation.
151 pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
153 self_expr: Option<&ast::Expr>,
158 self_ty: ty::Ty<'tcx>,
159 opt_input_types: Option<Vec<ty::Ty<'tcx>>>)
160 -> Option<ty::MethodCallee<'tcx>>
162 debug!("lookup_in_trait_adjusted(self_ty={:?}, self_expr={:?}, m_name={}, trait_def_id={:?})",
168 let trait_def = fcx.tcx().lookup_trait_def(trait_def_id);
170 let type_parameter_defs = trait_def.generics.types.get_slice(subst::TypeSpace);
171 let expected_number_of_input_types = type_parameter_defs.len();
173 assert_eq!(trait_def.generics.types.len(subst::FnSpace), 0);
174 assert!(trait_def.generics.regions.is_empty());
176 // Construct a trait-reference `self_ty : Trait<input_tys>`
177 let mut substs = subst::Substs::new_trait(Vec::new(), Vec::new(), self_ty);
179 match opt_input_types {
180 Some(input_types) => {
181 assert_eq!(expected_number_of_input_types, input_types.len());
182 substs.types.replace(subst::ParamSpace::TypeSpace, input_types);
186 fcx.inh.infcx.type_vars_for_defs(
188 subst::ParamSpace::TypeSpace,
190 type_parameter_defs);
194 let trait_ref = ty::TraitRef::new(trait_def_id, fcx.tcx().mk_substs(substs));
196 // Construct an obligation
197 let poly_trait_ref = trait_ref.to_poly_trait_ref();
198 let obligation = traits::Obligation::misc(span,
200 poly_trait_ref.to_predicate());
202 // Now we want to know if this can be matched
203 let mut selcx = traits::SelectionContext::new(fcx.infcx());
204 if !selcx.evaluate_obligation(&obligation) {
205 debug!("--> Cannot match obligation");
206 return None; // Cannot be matched, no such method resolution is possible.
209 // Trait must have a method named `m_name` and it should not have
210 // type parameters or early-bound regions.
212 let method_item = trait_item(tcx, trait_def_id, m_name).unwrap();
213 let method_ty = method_item.as_opt_method().unwrap();
214 assert_eq!(method_ty.generics.types.len(subst::FnSpace), 0);
215 assert_eq!(method_ty.generics.regions.len(subst::FnSpace), 0);
217 debug!("lookup_in_trait_adjusted: method_item={:?} method_ty={:?}",
218 method_item, method_ty);
220 // Instantiate late-bound regions and substitute the trait
221 // parameters into the method type to get the actual method type.
223 // NB: Instantiate late-bound regions first so that
224 // `instantiate_type_scheme` can normalize associated types that
225 // may reference those regions.
226 let fn_sig = fcx.infcx().replace_late_bound_regions_with_fresh_var(span,
228 &method_ty.fty.sig).0;
229 let fn_sig = fcx.instantiate_type_scheme(span, trait_ref.substs, &fn_sig);
230 let transformed_self_ty = fn_sig.inputs[0];
231 let fty = tcx.mk_fn(None, tcx.mk_bare_fn(ty::BareFnTy {
232 sig: ty::Binder(fn_sig),
233 unsafety: method_ty.fty.unsafety,
234 abi: method_ty.fty.abi.clone(),
237 debug!("lookup_in_trait_adjusted: matched method fty={:?} obligation={:?}",
241 // Register obligations for the parameters. This will include the
242 // `Self` parameter, which in turn has a bound of the main trait,
243 // so this also effectively registers `obligation` as well. (We
244 // used to register `obligation` explicitly, but that resulted in
245 // double error messages being reported.)
247 // Note that as the method comes from a trait, it should not have
248 // any late-bound regions appearing in its bounds.
249 let method_bounds = fcx.instantiate_bounds(span, trait_ref.substs, &method_ty.predicates);
250 assert!(!method_bounds.has_escaping_regions());
251 fcx.add_obligations_for_parameters(
252 traits::ObligationCause::misc(span, fcx.body_id),
255 // FIXME(#18653) -- Try to resolve obligations, giving us more
256 // typing information, which can sometimes be needed to avoid
257 // pathological region inference failures.
258 fcx.select_new_obligations();
260 // Insert any adjustments needed (always an autoref of some mutability).
265 debug!("lookup_in_trait_adjusted: inserting adjustment if needed \
266 (self-id={}, autoderefs={}, unsize={}, explicit_self={:?})",
267 self_expr.id, autoderefs, unsize,
268 method_ty.explicit_self);
270 match method_ty.explicit_self {
271 ty::ByValueExplicitSelfCategory => {
272 // Trait method is fn(self), no transformation needed.
274 fcx.write_autoderef_adjustment(self_expr.id, autoderefs);
277 ty::ByReferenceExplicitSelfCategory(..) => {
278 // Trait method is fn(&self) or fn(&mut self), need an
279 // autoref. Pull the region etc out of the type of first argument.
280 match transformed_self_ty.sty {
281 ty::TyRef(region, ty::TypeAndMut { mutbl, ty: _ }) => {
282 fcx.write_adjustment(self_expr.id,
283 ty::AdjustDerefRef(ty::AutoDerefRef {
284 autoderefs: autoderefs,
285 autoref: Some(ty::AutoPtr(region, mutbl)),
287 Some(transformed_self_ty)
295 fcx.tcx().sess.span_bug(
298 "trait method is &self but first arg is: {}",
299 transformed_self_ty));
305 fcx.tcx().sess.span_bug(
308 "unexpected explicit self type in operator method: {:?}",
309 method_ty.explicit_self));
315 let callee = ty::MethodCallee {
316 def_id: method_item.def_id(),
318 substs: trait_ref.substs
321 debug!("callee = {:?}", callee);
326 pub fn resolve_ufcs<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
328 method_name: ast::Name,
329 self_ty: ty::Ty<'tcx>,
330 expr_id: ast::NodeId)
331 -> Result<(def::Def, LastPrivate), MethodError<'tcx>>
333 let mode = probe::Mode::Path;
334 let pick = try!(probe::probe(fcx, span, mode, method_name, self_ty, expr_id));
335 let def_id = pick.item.def_id();
336 let mut lp = LastMod(AllPublic);
337 if let probe::InherentImplPick = pick.kind {
338 if pick.item.vis() != ast::Public {
339 lp = LastMod(DependsOn(def_id));
342 let def_result = match pick.item {
343 ty::ImplOrTraitItem::MethodTraitItem(..) => def::DefMethod(def_id),
344 ty::ImplOrTraitItem::ConstTraitItem(..) => def::DefAssociatedConst(def_id),
345 ty::ImplOrTraitItem::TypeTraitItem(..) => {
346 fcx.tcx().sess.span_bug(span, "resolve_ufcs: probe picked associated type");
353 /// Find item with name `item_name` defined in `trait_def_id`
354 /// and return it, or `None`, if no such item.
355 fn trait_item<'tcx>(tcx: &ty::ctxt<'tcx>,
356 trait_def_id: ast::DefId,
357 item_name: ast::Name)
358 -> Option<ty::ImplOrTraitItem<'tcx>>
360 let trait_items = tcx.trait_items(trait_def_id);
362 .find(|item| item.name() == item_name)
366 fn impl_item<'tcx>(tcx: &ty::ctxt<'tcx>,
367 impl_def_id: ast::DefId,
368 item_name: ast::Name)
369 -> Option<ty::ImplOrTraitItem<'tcx>>
371 let impl_items = tcx.impl_items.borrow();
372 let impl_items = impl_items.get(&impl_def_id).unwrap();
375 .map(|&did| tcx.impl_or_trait_item(did.def_id()))
376 .find(|m| m.name() == item_name)