diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs index aaab89ace0ad9..bd43d3c01e218 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs @@ -429,6 +429,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { body_id: Option, span: Span, arg: GenericArg<'tcx>, + impl_candidates: Vec>, error_code: TypeAnnotationNeeded, ) -> DiagnosticBuilder<'tcx> { let arg = self.resolve_vars_if_possible(arg); @@ -653,7 +654,44 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { }; err.span_label(pattern.span, msg); } else if let Some(e) = local_visitor.found_method_call { - if let ExprKind::MethodCall(segment, ..) = &e.kind { + if let ExprKind::MethodCall(segment, _, exprs, _) = &e.kind { + // Suggest impl candidates: + // + // error[E0283]: type annotations needed + // --> $DIR/E0283.rs:35:24 + // | + // LL | let bar = foo_impl.into() * 1u32; + // | ---------^^^^-- + // | | | + // | | cannot infer type for type parameter `T` declared on the trait `Into` + // | this method call resolves to `T` + // | help: specify type like: `>::into(foo_impl)` + // | + // = note: cannot satisfy `Impl: Into<_>` + if !impl_candidates.is_empty() && e.span.contains(span) { + if let Some(expr) = exprs.first() { + if let ExprKind::Path(hir::QPath::Resolved(_, path)) = expr.kind { + if let [path_segment] = &path.segments[..] { + let candidate_len = impl_candidates.len(); + let suggestions = impl_candidates.iter().map(|candidate| { + format!( + "{}::{}({})", + candidate, segment.ident, path_segment.ident + ) + }); + err.span_suggestions( + e.span, + &format!( + "use the fully qualified path for the potential candidate{}", + pluralize!(candidate_len), + ), + suggestions, + Applicability::MaybeIncorrect, + ); + } + } + }; + } // Suggest specifying type params or point out the return type of the call: // // error[E0282]: type annotations needed diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs index 3eeb5038f3693..a42a05c5f0284 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs @@ -1498,11 +1498,18 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { // check upstream for type errors and don't add the obligations to // begin with in those cases. if self.tcx.lang_items().sized_trait() == Some(trait_ref.def_id()) { - self.emit_inference_failure_err(body_id, span, subst, ErrorCode::E0282).emit(); + self.emit_inference_failure_err(body_id, span, subst, vec![], ErrorCode::E0282) + .emit(); return; } - let mut err = - self.emit_inference_failure_err(body_id, span, subst, ErrorCode::E0283); + let impl_candidates = self.find_similar_impl_candidates(trait_ref); + let mut err = self.emit_inference_failure_err( + body_id, + span, + subst, + impl_candidates, + ErrorCode::E0283, + ); err.note(&format!("cannot satisfy `{}`", predicate)); if let ObligationCauseCode::ItemObligation(def_id) = obligation.cause.code { self.suggest_fully_qualified_path(&mut err, def_id, span, trait_ref.def_id()); @@ -1566,7 +1573,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { return; } - self.emit_inference_failure_err(body_id, span, arg, ErrorCode::E0282) + self.emit_inference_failure_err(body_id, span, arg, vec![], ErrorCode::E0282) } ty::PredicateKind::Subtype(data) => { @@ -1577,7 +1584,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { let SubtypePredicate { a_is_expected: _, a, b } = data; // both must be type variables, or the other would've been instantiated assert!(a.is_ty_var() && b.is_ty_var()); - self.emit_inference_failure_err(body_id, span, a.into(), ErrorCode::E0282) + self.emit_inference_failure_err(body_id, span, a.into(), vec![], ErrorCode::E0282) } ty::PredicateKind::Projection(data) => { let trait_ref = bound_predicate.rebind(data).to_poly_trait_ref(self.tcx); @@ -1592,6 +1599,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { body_id, span, self_ty.into(), + vec![], ErrorCode::E0284, ); err.note(&format!("cannot satisfy `{}`", predicate)); diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs index 5a372c0aaabf1..c491ba3084192 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs @@ -1479,7 +1479,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ty } else { if !self.is_tainted_by_errors() { - self.emit_inference_failure_err((**self).body_id, sp, ty.into(), E0282) + self.emit_inference_failure_err((**self).body_id, sp, ty.into(), vec![], E0282) .note("type must be known at this point") .emit(); } diff --git a/compiler/rustc_typeck/src/check/writeback.rs b/compiler/rustc_typeck/src/check/writeback.rs index 6edce62f76bc9..9e6bf5ce52d8a 100644 --- a/compiler/rustc_typeck/src/check/writeback.rs +++ b/compiler/rustc_typeck/src/check/writeback.rs @@ -694,6 +694,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { Some(self.body.id()), self.span.to_span(self.tcx), t.into(), + vec![], E0282, ) .emit(); @@ -707,6 +708,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { Some(self.body.id()), self.span.to_span(self.tcx), c.into(), + vec![], E0282, ) .emit(); diff --git a/src/test/ui/error-codes/E0283.rs b/src/test/ui/error-codes/E0283.rs index 9bdcc9ac42a7a..4d7c2f2396d75 100644 --- a/src/test/ui/error-codes/E0283.rs +++ b/src/test/ui/error-codes/E0283.rs @@ -8,6 +8,18 @@ impl Generator for Impl { fn create() -> u32 { 1 } } +impl Impl { + fn new() -> Self { + Impl{} + } +} + +impl Into for Impl { + fn into(self) -> u32 { 1 } +} + +fn foo(bar: u32) {} + struct AnotherImpl; impl Generator for AnotherImpl { @@ -17,3 +29,9 @@ impl Generator for AnotherImpl { fn main() { let cont: u32 = Generator::create(); //~ ERROR E0283 } + +fn buzz() { + let foo_impl = Impl::new(); + let bar = foo_impl.into() * 1u32; //~ ERROR E0283 + foo(bar); +} diff --git a/src/test/ui/error-codes/E0283.stderr b/src/test/ui/error-codes/E0283.stderr index e95583c91a72f..2f0dfb6dd8248 100644 --- a/src/test/ui/error-codes/E0283.stderr +++ b/src/test/ui/error-codes/E0283.stderr @@ -1,5 +1,5 @@ error[E0283]: type annotations needed - --> $DIR/E0283.rs:18:21 + --> $DIR/E0283.rs:30:21 | LL | fn create() -> u32; | ------------------- required by `Generator::create` @@ -9,6 +9,18 @@ LL | let cont: u32 = Generator::create(); | = note: cannot satisfy `_: Generator` -error: aborting due to previous error +error[E0283]: type annotations needed + --> $DIR/E0283.rs:35:24 + | +LL | let bar = foo_impl.into() * 1u32; + | ---------^^^^-- + | | | + | | cannot infer type for type parameter `T` declared on the trait `Into` + | this method call resolves to `T` + | help: use the fully qualified path for the potential candidate: `>::into(foo_impl)` + | + = note: cannot satisfy `Impl: Into<_>` + +error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0283`.