-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Method lookup: the secret sauce of Rust. See `doc.rs`.
-
-use astconv::AstConv;
-use check::{FnCtxt};
-use check::{impl_self_ty};
-use check::vtable;
-use check::vtable::select_new_fcx_obligations;
-use middle::subst;
-use middle::traits;
-use middle::ty::*;
-use middle::ty;
-use middle::infer;
-use util::ppaux::{Repr, UserString};
-
-use std::rc::Rc;
-use syntax::ast::{DefId};
-use syntax::ast;
-use syntax::codemap::Span;
+//! Method lookup: the secret sauce of Rust. See the [rustc guide] for more information.
+//!
+//! [rustc guide]: https://rust-lang.github.io/rustc-guide/method-lookup.html
-pub use self::MethodError::*;
+mod confirm;
+pub mod probe;
+mod suggest;
+
+pub use self::suggest::{SelfSource, TraitInfo};
pub use self::CandidateSource::*;
+pub use self::MethodError::*;
-mod confirm;
-mod doc;
-mod probe;
+use crate::check::FnCtxt;
+use rustc::ty::subst::Subst;
+use rustc::ty::subst::{InternalSubsts, SubstsRef};
+use rustc::ty::GenericParamDefKind;
+use rustc::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TypeFoldable, WithConstness};
+use rustc_ast::ast;
+use rustc_data_structures::sync::Lrc;
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_hir as hir;
+use rustc_hir::def::{CtorOf, DefKind, Namespace};
+use rustc_hir::def_id::DefId;
+use rustc_infer::infer::{self, InferOk};
+use rustc_infer::traits;
+use rustc_span::Span;
+
+use self::probe::{IsSuggestion, ProbeScope};
+
+pub fn provide(providers: &mut ty::query::Providers<'_>) {
+ suggest::provide(providers);
+ probe::provide(providers);
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct MethodCallee<'tcx> {
+ /// Impl method ID, for inherent methods, or trait method ID, otherwise.
+ pub def_id: DefId,
+ pub substs: SubstsRef<'tcx>,
+
+ /// Instantiated method signature, i.e., it has been
+ /// substituted, normalized, and has had late-bound
+ /// lifetimes replaced with inference variables.
+ pub sig: ty::FnSig<'tcx>,
+}
-pub enum MethodError {
- // Did not find an applicable method, but we did find various
- // static methods that may apply.
- NoMatch(Vec<CandidateSource>),
+pub enum MethodError<'tcx> {
+ // Did not find an applicable method, but we did find various near-misses that may work.
+ NoMatch(NoMatchData<'tcx>),
// Multiple methods might apply.
Ambiguity(Vec<CandidateSource>),
-}
-// A pared down enum describing just the places from which a method
-// candidate can arise. Used for error reporting only.
-#[derive(Copy, PartialOrd, Ord, PartialEq, Eq)]
-pub enum CandidateSource {
- ImplSource(ast::DefId),
- TraitSource(/* trait id */ ast::DefId),
+ // Found an applicable method, but it is not visible. The third argument contains a list of
+ // not-in-scope traits which may work.
+ PrivateMatch(DefKind, DefId, Vec<DefId>),
+
+ // Found a `Self: Sized` bound where `Self` is a trait object, also the caller may have
+ // forgotten to import a trait.
+ IllegalSizedBound(Vec<DefId>, bool, Span),
+
+ // Found a match, but the return type is wrong
+ BadReturnType,
}
-type MethodIndex = uint; // just for doc purposes
-
-/// Determines whether the type `self_ty` supports a method name `method_name` or not.
-pub fn exists<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- span: Span,
- method_name: ast::Name,
- self_ty: Ty<'tcx>,
- call_expr_id: ast::NodeId)
- -> bool
-{
- match probe::probe(fcx, span, method_name, self_ty, call_expr_id) {
- Ok(_) => true,
- Err(NoMatch(_)) => false,
- Err(Ambiguity(_)) => true,
- }
+// Contains a list of static methods that may apply, a list of unsatisfied trait predicates which
+// could lead to matches if satisfied, and a list of not-in-scope traits which may work.
+pub struct NoMatchData<'tcx> {
+ pub static_candidates: Vec<CandidateSource>,
+ pub unsatisfied_predicates: Vec<(ty::Predicate<'tcx>, Option<ty::Predicate<'tcx>>)>,
+ pub out_of_scope_traits: Vec<DefId>,
+ pub lev_candidate: Option<ty::AssocItem>,
+ pub mode: probe::Mode,
}
-/// Performs method lookup. If lookup is successful, it will return the callee and store an
-/// appropriate adjustment for the self-expr. In some cases it may report an error (e.g., invoking
-/// the `drop` method).
-///
-/// # Arguments
-///
-/// Given a method call like `foo.bar::<T1,...Tn>(...)`:
-///
-/// * `fcx`: the surrounding `FnCtxt` (!)
-/// * `span`: the span for the method call
-/// * `method_name`: the name of the method being called (`bar`)
-/// * `self_ty`: the (unadjusted) type of the self expression (`foo`)
-/// * `supplied_method_types`: the explicit method type parameters, if any (`T1..Tn`)
-/// * `self_expr`: the self expression (`foo`)
-pub fn lookup<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- span: Span,
- method_name: ast::Name,
- self_ty: Ty<'tcx>,
- supplied_method_types: Vec<Ty<'tcx>>,
- call_expr: &ast::Expr,
- self_expr: &ast::Expr)
- -> Result<MethodCallee<'tcx>, MethodError>
-{
- debug!("lookup(method_name={}, self_ty={}, call_expr={}, self_expr={})",
- method_name.repr(fcx.tcx()),
- self_ty.repr(fcx.tcx()),
- call_expr.repr(fcx.tcx()),
- self_expr.repr(fcx.tcx()));
-
- let self_ty = fcx.infcx().resolve_type_vars_if_possible(&self_ty);
- let pick = try!(probe::probe(fcx, span, method_name, self_ty, call_expr.id));
- Ok(confirm::confirm(fcx, span, self_expr, call_expr, self_ty, pick, supplied_method_types))
+impl<'tcx> NoMatchData<'tcx> {
+ pub fn new(
+ static_candidates: Vec<CandidateSource>,
+ unsatisfied_predicates: Vec<(ty::Predicate<'tcx>, Option<ty::Predicate<'tcx>>)>,
+ out_of_scope_traits: Vec<DefId>,
+ lev_candidate: Option<ty::AssocItem>,
+ mode: probe::Mode,
+ ) -> Self {
+ NoMatchData {
+ static_candidates,
+ unsatisfied_predicates,
+ out_of_scope_traits,
+ lev_candidate,
+ mode,
+ }
+ }
}
-pub fn lookup_in_trait<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- span: Span,
- self_expr: Option<&ast::Expr>,
- m_name: ast::Name,
- trait_def_id: DefId,
- self_ty: Ty<'tcx>,
- opt_input_types: Option<Vec<Ty<'tcx>>>)
- -> Option<MethodCallee<'tcx>>
-{
- lookup_in_trait_adjusted(fcx, span, self_expr, m_name, trait_def_id,
- ty::AutoDerefRef { autoderefs: 0, autoref: None },
- self_ty, opt_input_types)
+// A pared down enum describing just the places from which a method
+// candidate can arise. Used for error reporting only.
+#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub enum CandidateSource {
+ ImplSource(DefId),
+ TraitSource(DefId /* trait id */),
}
-/// `lookup_in_trait_adjusted` is used for overloaded operators. It does a very narrow slice of
-/// what the normal probe/confirm path does. In particular, it doesn't really do any probing: it
-/// simply constructs an obligation for a particular trait with the given self-type and checks
-/// whether that trait is implemented.
-///
-/// FIXME(#18741) -- It seems likely that we can consolidate some of this code with the other
-/// method-lookup code. In particular, autoderef on index is basically identical to autoderef with
-/// normal probes, except that the test also looks for built-in indexing. Also, the second half of
-/// this method is basically the same as confirmation.
-pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- span: Span,
- self_expr: Option<&ast::Expr>,
- m_name: ast::Name,
- trait_def_id: DefId,
- autoderefref: ty::AutoDerefRef<'tcx>,
- self_ty: Ty<'tcx>,
- opt_input_types: Option<Vec<Ty<'tcx>>>)
- -> Option<MethodCallee<'tcx>>
-{
- debug!("lookup_in_trait_adjusted(self_ty={}, self_expr={}, m_name={}, trait_def_id={})",
- self_ty.repr(fcx.tcx()),
- self_expr.repr(fcx.tcx()),
- m_name.repr(fcx.tcx()),
- trait_def_id.repr(fcx.tcx()));
-
- let trait_def = ty::lookup_trait_def(fcx.tcx(), trait_def_id);
-
- let expected_number_of_input_types = trait_def.generics.types.len(subst::TypeSpace);
- let input_types = match opt_input_types {
- Some(input_types) => {
- assert_eq!(expected_number_of_input_types, input_types.len());
- input_types
+impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
+ /// Determines whether the type `self_ty` supports a method name `method_name` or not.
+ pub fn method_exists(
+ &self,
+ method_name: ast::Ident,
+ self_ty: Ty<'tcx>,
+ call_expr_id: hir::HirId,
+ allow_private: bool,
+ ) -> bool {
+ let mode = probe::Mode::MethodCall;
+ match self.probe_for_name(
+ method_name.span,
+ mode,
+ method_name,
+ IsSuggestion(false),
+ self_ty,
+ call_expr_id,
+ ProbeScope::TraitsInScope,
+ ) {
+ Ok(..) => true,
+ Err(NoMatch(..)) => false,
+ Err(Ambiguity(..)) => true,
+ Err(PrivateMatch(..)) => allow_private,
+ Err(IllegalSizedBound(..)) => true,
+ Err(BadReturnType) => bug!("no return type expectations but got BadReturnType"),
}
+ }
- None => {
- fcx.inh.infcx.next_ty_vars(expected_number_of_input_types)
- }
- };
-
- assert_eq!(trait_def.generics.types.len(subst::FnSpace), 0);
- assert!(trait_def.generics.regions.is_empty());
-
- // Construct a trait-reference `self_ty : Trait<input_tys>`
- let substs = subst::Substs::new_trait(input_types, Vec::new(), self_ty);
- let trait_ref = Rc::new(ty::TraitRef::new(trait_def_id, fcx.tcx().mk_substs(substs)));
-
- // Construct an obligation
- let poly_trait_ref = trait_ref.to_poly_trait_ref();
- let obligation = traits::Obligation::misc(span,
- fcx.body_id,
- poly_trait_ref.as_predicate());
-
- // Now we want to know if this can be matched
- let mut selcx = traits::SelectionContext::new(fcx.infcx(), fcx);
- if !selcx.evaluate_obligation(&obligation) {
- debug!("--> Cannot match obligation");
- return None; // Cannot be matched, no such method resolution is possible.
+ /// Adds a suggestion to call the given method to the provided diagnostic.
+ crate fn suggest_method_call(
+ &self,
+ err: &mut DiagnosticBuilder<'a>,
+ msg: &str,
+ method_name: ast::Ident,
+ self_ty: Ty<'tcx>,
+ call_expr: &hir::Expr<'_>,
+ ) {
+ let has_params = self
+ .probe_for_name(
+ method_name.span,
+ probe::Mode::MethodCall,
+ method_name,
+ IsSuggestion(false),
+ self_ty,
+ call_expr.hir_id,
+ ProbeScope::TraitsInScope,
+ )
+ .and_then(|pick| {
+ let sig = self.tcx.fn_sig(pick.item.def_id);
+ Ok(sig.inputs().skip_binder().len() > 1)
+ });
+
+ // Account for `foo.bar<T>`;
+ let sugg_span = method_name.span.with_hi(call_expr.span.hi());
+ let snippet = self
+ .tcx
+ .sess
+ .source_map()
+ .span_to_snippet(sugg_span)
+ .unwrap_or_else(|_| method_name.to_string());
+ let (suggestion, applicability) = if has_params.unwrap_or_default() {
+ (format!("{}(...)", snippet), Applicability::HasPlaceholders)
+ } else {
+ (format!("{}()", snippet), Applicability::MaybeIncorrect)
+ };
+
+ err.span_suggestion(sugg_span, msg, suggestion, applicability);
}
- // Trait must have a method named `m_name` and it should not have
- // type parameters or early-bound regions.
- let tcx = fcx.tcx();
- let (method_num, method_ty) = trait_method(tcx, trait_def_id, m_name).unwrap();
- assert_eq!(method_ty.generics.types.len(subst::FnSpace), 0);
- assert_eq!(method_ty.generics.regions.len(subst::FnSpace), 0);
+ /// Performs method lookup. If lookup is successful, it will return the callee
+ /// and store an appropriate adjustment for the self-expr. In some cases it may
+ /// report an error (e.g., invoking the `drop` method).
+ ///
+ /// # Arguments
+ ///
+ /// Given a method call like `foo.bar::<T1,...Tn>(...)`:
+ ///
+ /// * `fcx`: the surrounding `FnCtxt` (!)
+ /// * `span`: the span for the method call
+ /// * `method_name`: the name of the method being called (`bar`)
+ /// * `self_ty`: the (unadjusted) type of the self expression (`foo`)
+ /// * `supplied_method_types`: the explicit method type parameters, if any (`T1..Tn`)
+ /// * `self_expr`: the self expression (`foo`)
+ pub fn lookup_method(
+ &self,
+ self_ty: Ty<'tcx>,
+ segment: &hir::PathSegment<'_>,
+ span: Span,
+ call_expr: &'tcx hir::Expr<'tcx>,
+ self_expr: &'tcx hir::Expr<'tcx>,
+ ) -> Result<MethodCallee<'tcx>, MethodError<'tcx>> {
+ debug!(
+ "lookup(method_name={}, self_ty={:?}, call_expr={:?}, self_expr={:?})",
+ segment.ident, self_ty, call_expr, self_expr
+ );
+
+ let pick =
+ self.lookup_probe(span, segment.ident, self_ty, call_expr, ProbeScope::TraitsInScope)?;
+
+ for import_id in &pick.import_ids {
+ let import_def_id = self.tcx.hir().local_def_id(*import_id);
+ debug!("used_trait_import: {:?}", import_def_id);
+ Lrc::get_mut(&mut self.tables.borrow_mut().used_trait_imports)
+ .unwrap()
+ .insert(import_def_id);
+ }
+
+ self.tcx.check_stability(pick.item.def_id, Some(call_expr.hir_id), span);
- debug!("lookup_in_trait_adjusted: method_num={} method_ty={}",
- method_num, method_ty.repr(fcx.tcx()));
+ let result =
+ self.confirm_method(span, self_expr, call_expr, self_ty, pick.clone(), segment);
- // Instantiate late-bound regions and substitute the trait
- // parameters into the method type to get the actual method type.
- //
- // NB: Instantiate late-bound regions first so that
- // `instantiate_type_scheme` can normalize associated types that
- // may reference those regions.
- let fn_sig = fcx.infcx().replace_late_bound_regions_with_fresh_var(span,
- infer::FnCall,
- &method_ty.fty.sig).0;
- let fn_sig = fcx.instantiate_type_scheme(span, trait_ref.substs, &fn_sig);
- let transformed_self_ty = fn_sig.inputs[0];
- let fty = ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(ty::BareFnTy {
- sig: ty::Binder(fn_sig),
- unsafety: method_ty.fty.unsafety,
- abi: method_ty.fty.abi.clone(),
- }));
-
- debug!("lookup_in_trait_adjusted: matched method fty={} obligation={}",
- fty.repr(fcx.tcx()),
- obligation.repr(fcx.tcx()));
-
- // Register obligations for the parameters. This will include the
- // `Self` parameter, which in turn has a bound of the main trait,
- // so this also effectively registers `obligation` as well. (We
- // used to register `obligation` explicitly, but that resulted in
- // double error messages being reported.)
- //
- // Note that as the method comes from a trait, it should not have
- // any late-bound regions appearing in its bounds.
- let method_bounds = fcx.instantiate_bounds(span, trait_ref.substs, &method_ty.generics);
- assert!(!method_bounds.has_escaping_regions());
- fcx.add_obligations_for_parameters(
- traits::ObligationCause::misc(span, fcx.body_id),
- &method_bounds);
-
- // FIXME(#18653) -- Try to resolve obligations, giving us more
- // typing information, which can sometimes be needed to avoid
- // pathological region inference failures.
- vtable::select_new_fcx_obligations(fcx);
-
- // Insert any adjustments needed (always an autoref of some mutability).
- match self_expr {
- None => { }
-
- Some(self_expr) => {
- debug!("lookup_in_trait_adjusted: inserting adjustment if needed \
- (self-id={}, base adjustment={:?}, explicit_self={:?})",
- self_expr.id, autoderefref, method_ty.explicit_self);
-
- match method_ty.explicit_self {
- ty::ByValueExplicitSelfCategory => {
- // Trait method is fn(self), no transformation needed.
- if !autoderefref.is_identity() {
- fcx.write_adjustment(
- self_expr.id,
- span,
- ty::AdjustDerefRef(autoderefref));
+ if let Some(span) = result.illegal_sized_bound {
+ let mut needs_mut = false;
+ if let ty::Ref(region, t_type, mutability) = self_ty.kind {
+ let trait_type = self
+ .tcx
+ .mk_ref(region, ty::TypeAndMut { ty: t_type, mutbl: mutability.invert() });
+ // We probe again to see if there might be a borrow mutability discrepancy.
+ match self.lookup_probe(
+ span,
+ segment.ident,
+ trait_type,
+ call_expr,
+ ProbeScope::TraitsInScope,
+ ) {
+ Ok(ref new_pick) if *new_pick != pick => {
+ needs_mut = true;
}
+ _ => {}
}
+ }
- ty::ByReferenceExplicitSelfCategory(..) => {
- // Trait method is fn(&self) or fn(&mut self), need an
- // autoref. Pull the region etc out of the type of first argument.
- match transformed_self_ty.sty {
- ty::ty_rptr(region, ty::mt { mutbl, ty: _ }) => {
- let ty::AutoDerefRef { autoderefs, autoref } = autoderefref;
- let autoref = autoref.map(|r| box r);
- fcx.write_adjustment(
- self_expr.id,
- span,
- ty::AdjustDerefRef(ty::AutoDerefRef {
- autoderefs: autoderefs,
- autoref: Some(ty::AutoPtr(*region, mutbl, autoref))
- }));
+ // We probe again, taking all traits into account (not only those in scope).
+ let candidates = match self.lookup_probe(
+ span,
+ segment.ident,
+ self_ty,
+ call_expr,
+ ProbeScope::AllTraits,
+ ) {
+ // If we find a different result the caller probably forgot to import a trait.
+ Ok(ref new_pick) if *new_pick != pick => vec![new_pick.item.container.id()],
+ Err(Ambiguity(ref sources)) => sources
+ .iter()
+ .filter_map(|source| {
+ match *source {
+ // Note: this cannot come from an inherent impl,
+ // because the first probing succeeded.
+ ImplSource(def) => self.tcx.trait_id_of_impl(def),
+ TraitSource(_) => None,
}
+ })
+ .collect(),
+ _ => Vec::new(),
+ };
- _ => {
- fcx.tcx().sess.span_bug(
- span,
- &format!(
- "trait method is &self but first arg is: {}",
- transformed_self_ty.repr(fcx.tcx()))[]);
- }
- }
- }
+ return Err(IllegalSizedBound(candidates, needs_mut, span));
+ }
+
+ Ok(result.callee)
+ }
+
+ pub fn lookup_probe(
+ &self,
+ span: Span,
+ method_name: ast::Ident,
+ self_ty: Ty<'tcx>,
+ call_expr: &'tcx hir::Expr<'tcx>,
+ scope: ProbeScope,
+ ) -> probe::PickResult<'tcx> {
+ let mode = probe::Mode::MethodCall;
+ let self_ty = self.resolve_vars_if_possible(&self_ty);
+ self.probe_for_name(
+ span,
+ mode,
+ method_name,
+ IsSuggestion(false),
+ self_ty,
+ call_expr.hir_id,
+ scope,
+ )
+ }
- _ => {
- fcx.tcx().sess.span_bug(
- span,
- &format!(
- "unexpected explicit self type in operator method: {:?}",
- method_ty.explicit_self)[]);
+ /// `lookup_method_in_trait` is used for overloaded operators.
+ /// It does a very narrow slice of what the normal probe/confirm path does.
+ /// In particular, it doesn't really do any probing: it simply constructs
+ /// an obligation for a particular trait with the given self type and checks
+ /// whether that trait is implemented.
+ //
+ // FIXME(#18741): it seems likely that we can consolidate some of this
+ // code with the other method-lookup code. In particular, the second half
+ // of this method is basically the same as confirmation.
+ pub fn lookup_method_in_trait(
+ &self,
+ span: Span,
+ m_name: ast::Ident,
+ trait_def_id: DefId,
+ self_ty: Ty<'tcx>,
+ opt_input_types: Option<&[Ty<'tcx>]>,
+ ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
+ debug!(
+ "lookup_in_trait_adjusted(self_ty={:?}, \
+ m_name={}, trait_def_id={:?})",
+ self_ty, m_name, trait_def_id
+ );
+
+ // Construct a trait-reference `self_ty : Trait<input_tys>`
+ let substs = InternalSubsts::for_item(self.tcx, trait_def_id, |param, _| {
+ match param.kind {
+ GenericParamDefKind::Lifetime | GenericParamDefKind::Const => {}
+ GenericParamDefKind::Type { .. } => {
+ if param.index == 0 {
+ return self_ty.into();
+ } else if let Some(ref input_types) = opt_input_types {
+ return input_types[param.index as usize - 1].into();
+ }
}
}
+ self.var_for_def(span, param)
+ });
+
+ let trait_ref = ty::TraitRef::new(trait_def_id, substs);
+
+ // Construct an obligation
+ let poly_trait_ref = trait_ref.to_poly_trait_ref();
+ let obligation = traits::Obligation::misc(
+ span,
+ self.body_id,
+ self.param_env,
+ poly_trait_ref.without_const().to_predicate(),
+ );
+
+ // Now we want to know if this can be matched
+ if !self.predicate_may_hold(&obligation) {
+ debug!("--> Cannot match obligation");
+ return None; // Cannot be matched, no such method resolution is possible.
}
- }
- let callee = MethodCallee {
- origin: MethodTypeParam(MethodParam{trait_ref: trait_ref.clone(),
- method_num: method_num}),
- ty: fty,
- substs: trait_ref.substs.clone()
- };
+ // Trait must have a method named `m_name` and it should not have
+ // type parameters or early-bound regions.
+ let tcx = self.tcx;
+ let method_item = match self.associated_item(trait_def_id, m_name, Namespace::ValueNS) {
+ Some(method_item) => method_item,
+ None => {
+ tcx.sess.delay_span_bug(
+ span,
+ "operator trait does not have corresponding operator method",
+ );
+ return None;
+ }
+ };
+ let def_id = method_item.def_id;
+ let generics = tcx.generics_of(def_id);
+ assert_eq!(generics.params.len(), 0);
+
+ debug!("lookup_in_trait_adjusted: method_item={:?}", method_item);
+ let mut obligations = vec![];
+
+ // Instantiate late-bound regions and substitute the trait
+ // parameters into the method type to get the actual method type.
+ //
+ // N.B., instantiate late-bound regions first so that
+ // `instantiate_type_scheme` can normalize associated types that
+ // may reference those regions.
+ let fn_sig = tcx.fn_sig(def_id);
+ let fn_sig = self.replace_bound_vars_with_fresh_vars(span, infer::FnCall, &fn_sig).0;
+ let fn_sig = fn_sig.subst(self.tcx, substs);
+ let fn_sig = match self.normalize_associated_types_in_as_infer_ok(span, &fn_sig) {
+ InferOk { value, obligations: o } => {
+ obligations.extend(o);
+ value
+ }
+ };
+
+ // Register obligations for the parameters. This will include the
+ // `Self` parameter, which in turn has a bound of the main trait,
+ // so this also effectively registers `obligation` as well. (We
+ // used to register `obligation` explicitly, but that resulted in
+ // double error messages being reported.)
+ //
+ // Note that as the method comes from a trait, it should not have
+ // any late-bound regions appearing in its bounds.
+ let bounds = self.tcx.predicates_of(def_id).instantiate(self.tcx, substs);
+ let bounds = match self.normalize_associated_types_in_as_infer_ok(span, &bounds) {
+ InferOk { value, obligations: o } => {
+ obligations.extend(o);
+ value
+ }
+ };
+ assert!(!bounds.has_escaping_bound_vars());
- debug!("callee = {}", callee.repr(fcx.tcx()));
+ let cause = traits::ObligationCause::misc(span, self.body_id);
+ obligations.extend(traits::predicates_for_generics(cause.clone(), self.param_env, &bounds));
- Some(callee)
-}
+ // Also add an obligation for the method type being well-formed.
+ let method_ty = tcx.mk_fn_ptr(ty::Binder::bind(fn_sig));
+ debug!(
+ "lookup_in_trait_adjusted: matched method method_ty={:?} obligation={:?}",
+ method_ty, obligation
+ );
+ obligations.push(traits::Obligation::new(
+ cause,
+ self.param_env,
+ ty::Predicate::WellFormed(method_ty),
+ ));
-pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- span: Span,
- rcvr_ty: Ty<'tcx>,
- method_name: ast::Name,
- error: MethodError)
-{
- match error {
- NoMatch(static_sources) => {
- let cx = fcx.tcx();
- let method_ustring = method_name.user_string(cx);
-
- // True if the type is a struct and contains a field with
- // the same name as the not-found method
- let is_field = match rcvr_ty.sty {
- ty_struct(did, _) =>
- ty::lookup_struct_fields(cx, did)
- .iter()
- .any(|f| f.name.user_string(cx) == method_ustring),
- _ => false
- };
+ let callee = MethodCallee { def_id, substs: trait_ref.substs, sig: fn_sig };
- fcx.type_error_message(
- span,
- |actual| {
- format!("type `{}` does not implement any \
- method in scope named `{}`",
- actual,
- method_ustring)
- },
- rcvr_ty,
- None);
-
- // If the method has the name of a field, give a help note
- if is_field {
- cx.sess.span_note(span,
- &format!("use `(s.{0})(...)` if you meant to call the \
- function stored in the `{0}` field", method_ustring)[]);
- }
+ debug!("callee = {:?}", callee);
- if static_sources.len() > 0 {
- fcx.tcx().sess.fileline_note(
- span,
- "found defined static methods, maybe a `self` is missing?");
+ Some(InferOk { obligations, value: callee })
+ }
- report_candidates(fcx, span, method_name, static_sources);
+ pub fn resolve_ufcs(
+ &self,
+ span: Span,
+ method_name: ast::Ident,
+ self_ty: Ty<'tcx>,
+ expr_id: hir::HirId,
+ ) -> Result<(DefKind, DefId), MethodError<'tcx>> {
+ debug!(
+ "resolve_ufcs: method_name={:?} self_ty={:?} expr_id={:?}",
+ method_name, self_ty, expr_id,
+ );
+
+ let tcx = self.tcx;
+
+ // Check if we have an enum variant.
+ if let ty::Adt(adt_def, _) = self_ty.kind {
+ if adt_def.is_enum() {
+ let variant_def = adt_def
+ .variants
+ .iter()
+ .find(|vd| tcx.hygienic_eq(method_name, vd.ident, adt_def.did));
+ if let Some(variant_def) = variant_def {
+ // Braced variants generate unusable names in value namespace (reserved for
+ // possible future use), so variants resolved as associated items may refer to
+ // them as well. It's ok to use the variant's id as a ctor id since an
+ // error will be reported on any use of such resolution anyway.
+ let ctor_def_id = variant_def.ctor_def_id.unwrap_or(variant_def.def_id);
+ tcx.check_stability(ctor_def_id, Some(expr_id), span);
+ return Ok((
+ DefKind::Ctor(CtorOf::Variant, variant_def.ctor_kind),
+ ctor_def_id,
+ ));
+ }
}
}
- Ambiguity(sources) => {
- span_err!(fcx.sess(), span, E0034,
- "multiple applicable methods in scope");
-
- report_candidates(fcx, span, method_name, sources);
- }
- }
-
- fn report_candidates(fcx: &FnCtxt,
- span: Span,
- method_name: ast::Name,
- mut sources: Vec<CandidateSource>) {
- sources.sort();
- sources.dedup();
-
- for (idx, source) in sources.iter().enumerate() {
- match *source {
- ImplSource(impl_did) => {
- // Provide the best span we can. Use the method, if local to crate, else
- // the impl, if local to crate (method may be defaulted), else the call site.
- let method = impl_method(fcx.tcx(), impl_did, method_name).unwrap();
- let impl_span = fcx.tcx().map.def_id_span(impl_did, span);
- let method_span = fcx.tcx().map.def_id_span(method.def_id, impl_span);
-
- let impl_ty = impl_self_ty(fcx, span, impl_did).ty;
-
- let insertion = match impl_trait_ref(fcx.tcx(), impl_did) {
- None => format!(""),
- Some(trait_ref) => format!(" of the trait `{}`",
- ty::item_path_str(fcx.tcx(),
- trait_ref.def_id)),
- };
-
- span_note!(fcx.sess(), method_span,
- "candidate #{} is defined in an impl{} for the type `{}`",
- idx + 1u,
- insertion,
- impl_ty.user_string(fcx.tcx()));
- }
- TraitSource(trait_did) => {
- let (_, method) = trait_method(fcx.tcx(), trait_did, method_name).unwrap();
- let method_span = fcx.tcx().map.def_id_span(method.def_id, span);
- span_note!(fcx.sess(), method_span,
- "candidate #{} is defined in the trait `{}`",
- idx + 1u,
- ty::item_path_str(fcx.tcx(), trait_did));
- }
+ let pick = self.probe_for_name(
+ span,
+ probe::Mode::Path,
+ method_name,
+ IsSuggestion(false),
+ self_ty,
+ expr_id,
+ ProbeScope::TraitsInScope,
+ )?;
+ debug!("resolve_ufcs: pick={:?}", pick);
+ {
+ let mut tables = self.tables.borrow_mut();
+ let used_trait_imports = Lrc::get_mut(&mut tables.used_trait_imports).unwrap();
+ for import_id in pick.import_ids {
+ let import_def_id = tcx.hir().local_def_id(import_id);
+ debug!("resolve_ufcs: used_trait_import: {:?}", import_def_id);
+ used_trait_imports.insert(import_def_id);
}
}
- }
-}
-/// Find method with name `method_name` defined in `trait_def_id` and return it, along with its
-/// index (or `None`, if no such method).
-fn trait_method<'tcx>(tcx: &ty::ctxt<'tcx>,
- trait_def_id: ast::DefId,
- method_name: ast::Name)
- -> Option<(uint, Rc<ty::Method<'tcx>>)>
-{
- let trait_items = ty::trait_items(tcx, trait_def_id);
- trait_items
- .iter()
- .enumerate()
- .find(|&(_, ref item)| item.name() == method_name)
- .and_then(|(idx, item)| item.as_opt_method().map(|m| (idx, m)))
-}
+ let def_kind = pick.item.def_kind();
+ debug!("resolve_ufcs: def_kind={:?}, def_id={:?}", def_kind, pick.item.def_id);
+ tcx.check_stability(pick.item.def_id, Some(expr_id), span);
+ Ok((def_kind, pick.item.def_id))
+ }
-fn impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
- impl_def_id: ast::DefId,
- method_name: ast::Name)
- -> Option<Rc<ty::Method<'tcx>>>
-{
- let impl_items = tcx.impl_items.borrow();
- let impl_items = impl_items.get(&impl_def_id).unwrap();
- impl_items
- .iter()
- .map(|&did| ty::impl_or_trait_item(tcx, did.def_id()))
- .find(|m| m.name() == method_name)
- .and_then(|item| item.as_opt_method())
+ /// Finds item with name `item_name` defined in impl/trait `def_id`
+ /// and return it, or `None`, if no such item was defined there.
+ pub fn associated_item(
+ &self,
+ def_id: DefId,
+ item_name: ast::Ident,
+ ns: Namespace,
+ ) -> Option<ty::AssocItem> {
+ self.tcx
+ .associated_items(def_id)
+ .find_by_name_and_namespace(self.tcx, item_name, ns, def_id)
+ .copied()
+ }
}
projects / rustc.git / blobdiff