Check built-in operator obligation before the method's WF obligations so as to not incompletely guide inference

Author: compiler-errors

compiler/rustc_hir_typeck/src/method/mod.rs

@@ -359,7 +359,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let obligation = traits::Obligation::new(
             self.tcx,
-            cause,
+            cause.clone(),
             self.param_env,
             ty::TraitRef::new_from_args(self.tcx, trait_def_id, args),
         );
@@ -385,6 +385,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         debug!("lookup_in_trait_adjusted: method_item={:?}", method_item);
         let mut obligations = PredicateObligations::new();
+        // Register the operator's obligation first to constrain the "rhs" argument (or inputs
+        // for a fn-like operator). This would happen coincidentally as part of normalizing the
+        // signature below if the output type is constrained but a param-env predicate, but for
+        // `AsyncFn*`, the output type doesn't actually show up in the signature, so we end up
+        // trying to prove other WF predicates first which incompletely constrains the type.
+        obligations.push(obligation);
 
         // Instantiate late-bound regions and instantiate the trait
         // parameters into the method type to get the actual method type.
@@ -393,11 +399,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // function signature so that normalization does not need to deal
         // with bound regions.
         let fn_sig = tcx.fn_sig(def_id).instantiate(self.tcx, args);
-        let fn_sig =
-            self.instantiate_binder_with_fresh_vars(obligation.cause.span, infer::FnCall, fn_sig);
+        let fn_sig = self.instantiate_binder_with_fresh_vars(cause.span, infer::FnCall, fn_sig);
 
         let InferOk { value: fn_sig, obligations: o } =
-            self.at(&obligation.cause, self.param_env).normalize(fn_sig);
+            self.at(&cause, self.param_env).normalize(fn_sig);
         obligations.extend(o);
 
         // Register obligations for the parameters. This will include the
@@ -411,26 +416,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let bounds = self.tcx.predicates_of(def_id).instantiate(self.tcx, args);
 
         let InferOk { value: bounds, obligations: o } =
-            self.at(&obligation.cause, self.param_env).normalize(bounds);
+            self.at(&cause, self.param_env).normalize(bounds);
         obligations.extend(o);
         assert!(!bounds.has_escaping_bound_vars());
 
-        let predicates_cause = obligation.cause.clone();
         obligations.extend(traits::predicates_for_generics(
-            move |_, _| predicates_cause.clone(),
+            |_, _| cause.clone(),
             self.param_env,
             bounds,
         ));
 
         // Also add an obligation for the method type being well-formed.
         let method_ty = Ty::new_fn_ptr(tcx, ty::Binder::dummy(fn_sig));
-        debug!(
-            "lookup_method_in_trait: matched method method_ty={:?} obligation={:?}",
-            method_ty, obligation
-        );
+        debug!("lookup_method_in_trait: matched method method_ty={:?}", method_ty);
+
         obligations.push(traits::Obligation::new(
             tcx,
-            obligation.cause,
+            cause.clone(),
             self.param_env,
             ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(
                 method_ty.into(),

tests/ui/async-await/async-fn/incomplete-constrain-builtin.rs

@@ -0,0 +1,23 @@
+//@ check-pass
+
+// Ensure that a param-env predicate like `(T,): Sized` doesn't get in the way of us
+// confirming the built-in call operator for `AsyncFnOnce`. This happens because we
+// end up with a signature like:
+//
+// `<F as AsyncFnOnce<(?0,)>>::async_call_once(self) -> <F as AsyncFnOnce<(?0,)>>::CallOnceFuture`
+//
+// (where we use fresh infer vars for each arg since we haven't actually typeck'd the args yet).
+// But normalizing that signature keeps the associated type rigid, so we don't end up
+// constraining `?0` like we would if we were normalizing the analogous `FnOnce` call...
+// Then we were checking that the method signature was WF, which would incompletely constrain
+// `(?0,) == (T,)` via the param-env, leading to us later failing on `F: AsyncFnOnce<(T,)>`.
+
+fn run<F, T>(f: F)
+where
+    F: AsyncFnOnce(i32),
+    (T,): Sized,
+{
+    f(1i32);
+}
+
+fn main() {}

tests/ui/inference/issue-70082.stderr

@@ -1,12 +1,14 @@
-error[E0284]: type annotations needed
+error[E0283]: type annotations needed
   --> $DIR/issue-70082.rs:7:33
    |
 LL |     let y: f64 = 0.01f64 * 1i16.into();
    |                          -      ^^^^
    |                          |
    |                          type must be known at this point
    |
-   = note: cannot satisfy `<f64 as Mul<_>>::Output == f64`
+   = note: multiple `impl`s satisfying `f64: Mul<_>` found in the `core` crate:
+           - impl Mul for f64;
+           - impl Mul<&f64> for f64;
 help: try using a fully qualified path to specify the expected types
    |
 LL -     let y: f64 = 0.01f64 * 1i16.into();
@@ -15,4 +17,4 @@ LL +     let y: f64 = 0.01f64 * <i16 as Into<T>>::into(1i16);
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0284`.
+For more information about this error, try `rustc --explain E0283`.

tests/ui/inference/issue-71584.stderr

@@ -1,12 +1,15 @@
-error[E0284]: type annotations needed
+error[E0283]: type annotations needed
   --> $DIR/issue-71584.rs:5:15
    |
 LL |     d = d % n.into();
    |           -   ^^^^
    |           |
    |           type must be known at this point
    |
-   = note: cannot satisfy `<u64 as Rem<_>>::Output == u64`
+   = note: multiple `impl`s satisfying `u64: Rem<_>` found in the `core` crate:
+           - impl Rem for u64;
+           - impl Rem<&u64> for u64;
+           - impl Rem<NonZero<u64>> for u64;
 help: try using a fully qualified path to specify the expected types
    |
 LL -     d = d % n.into();
@@ -15,4 +18,4 @@ LL +     d = d % <u32 as Into<T>>::into(n);
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0284`.
+For more information about this error, try `rustc --explain E0283`.

tests/ui/issues/issue-24036.stderr

@@ -11,19 +11,21 @@ LL |     x = |c| c + 1;
    = note: no two closures, even if identical, have the same type
    = help: consider boxing your closure and/or using it as a trait object
 
-error[E0284]: type annotations needed
+error[E0283]: type annotations needed
   --> $DIR/issue-24036.rs:9:15
    |
 LL |         1 => |c| c + 1,
    |               ^    - type must be known at this point
    |
-   = note: cannot satisfy `<_ as Add<i32>>::Output == _`
+   = note: multiple `impl`s satisfying `_: Add<i32>` found in the `core` crate:
+           - impl Add for i32;
+           - impl<'a> Add<i32> for &'a i32;
 help: consider giving this closure parameter an explicit type
    |
 LL |         1 => |c: /* Type */| c + 1,
    |                ++++++++++++
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0284, E0308.
-For more information about an error, try `rustc --explain E0284`.
+Some errors have detailed explanations: E0283, E0308.
+For more information about an error, try `rustc --explain E0283`.