Change:
<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for how to create smaller examples. --It seems this is a particularly tricky interaction of , coercion and these two ; take away any one, and the compiler spits out a type annotation error as seen below. The compiler is also happy if is annotated as but I don't quite understand why this needs to be specified, given the inner casts on both branches. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details
reduced a bit
Regression in nightly-2020-06-24
This is minimized in the sense that spurious errors are avoided: The problem here is that the autoderef of a method is interacting strangely with the obligation registered by the line. This actually guides inference in such a way that an assertion in the compiler is not upheld -- that assertion is kinda nonsense though, so I'm just gonna rework it.
I've tried bisecting to a narrower point but didn't get far: commit[0] 2020-06-22: Auto merge of - ehuss:update-cargo, r=ehuss commit[1] 2020-06-22: Auto merge of - Aaron1011:revert/move-fn-self-msg, r=Manishearth commit[2] 2020-06-23: Auto merge of - yoshuawuyts:socketaddr-from-string-u16, r=sfackler commit[3] 2020-06-23: Auto merge of - Dylan-DPC:rollup-b4wbp42, r=Dylan-DPC commit[4] 2020-06-23: Auto merge of - Manishearth:rollup-68dr8fz, r=Manishearth commit[5] 2020-06-23: Auto merge of - ollie27:rustdocaliasfilter, r=GuillaumeGomez So I guess one , or WG-prioritization assigning priority (). label -I-prioritize +P-low

Discussion:
use rustc_hir_analysis::autoderef::{self, Autoderef}; use rustc_infer::infer::canonical::OriginalQueryValues; use rustc_infer::infer::canonical::{Canonical, QueryResponse}; <ins> use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282; </ins> use rustc_infer::infer::DefineOpaqueTypes; use rustc_infer::infer::{self, InferOk, TyCtxtInferExt}; use rustc_middle::middle::stability;

); } } else { <del> // Encountered a real ambiguity, so abort the lookup. If `ty` is not // an `Err`, report the right "type annotations needed" error pointing // to it. </del> <ins> // Ended up encountering a type variable when doing autoderef, // but it may not be a type variable after processing obligations // in our local `FnCtxt`, so don't call `structurally_resolved_type`. </ins> let ty = &bad_ty.ty; let ty = self .probe_instantiate_query_response(span, &orig_values, ty) .unwrap_or_else(|_| span_bug!(span, "instantiating {:?} failed?", ty)); <del> let ty = self.structurally_resolved_type(span, ty.value); assert!(matches!(ty.kind(), ty::Error(_))); </del> <ins> let ty = self.resolve_vars_if_possible(ty.value); let guar = match *ty.kind() { ty::Infer(ty::TyVar(_)) => self .err_ctxt() .emit_inference_failure_err(self.body_id, span, ty.into(), E0282, true) .emit(), ty::Error(guar) => guar, _ => bug!("unexpected bad final type in method autoderef"), }; self.demand_eqtype(span, ty, self.tcx.ty_error(guar)); </ins> return Err(MethodError::NoMatch(NoMatchData { static_candidates: Vec::new(), unsatisfied_predicates: Vec::new(),

<ins> use std::ops::Deref; use std::rc::Rc; struct Value<T>(T); pub trait Wrap<T> { fn wrap() -> Self; } impl<R, A1, A2> Wrap<fn(A1, A2) -> R> for Value<fn(A1, A2) -> R> { fn wrap() -> Self { todo!() } } impl<F, R, A1, A2> Wrap<F> for Value<Rc<dyn Fn(A1, A2) -> R>> { fn wrap() -> Self { todo!() } } impl<F> Deref for Value<Rc<F>> { type Target = F; fn deref(&self) -> &Self::Target { &*self.0 } } fn main() { let var_fn = Value::wrap(); //~^ ERROR type annotations needed for `Value<Rc<_>>` // The combination of `Value: Wrap` obligation plus the autoderef steps // (caused by the `Deref` impl above) actually means that the self type // of the method fn below is constrained to be `Value<Rc<dyn Fn(?0, ?1) -> ?2>>`. // However, that's only known to us on the error path -- we still need // to emit an ambiguity error, though. let _ = var_fn.clone(); } </ins>

<ins> error[E0282]: type annotations needed for `Value<Rc<_>>` --> $DIR/deref-ambiguity-becomes-nonambiguous.rs:31:9 | LL |     let var_fn = Value::wrap(); |         ^^^^^^ ... LL |     let _ = var_fn.clone(); |                    ----- type must be known at this point | help: consider giving `var_fn` an explicit type, where the placeholders `_` are specified | LL |     let var_fn: Value<Rc<_>> = Value::wrap(); |               ++++++++++++++ error: aborting due to previous error For more information about this error, try `rustc --explain E0282`. </ins>