Auto merge of rust-lang#123962 - oli-obk:define_opaque_types5, r=<try>

change method resolution to constrain hidden types instead of rejecting method candidates

Some of these are in probes and may affect inference. This is therefore a breaking change.

This allows new code to compile on stable:

```rust
trait Trait {}

impl Trait for u32 {}

struct Bar<T>(T);

impl Bar<u32> {
    fn foo(self) {}
}

fn foo(x: bool) -> Bar<impl Sized> {
    if x {
        let x = foo(false);
        x.foo();
        //^ this used to not find the `foo` method, because while we did equate `x`'s type with possible candidates, we didn't allow opaque type inference while doing so
    }
    todo!()
}
```

But it is also a breaking change, since `&self` and `&mut self` method calls on recursive RPIT function calls now constrain the hidden type to `&_` and `&mut _` respectively. This is not what users really expect or want from this, but there's way around this.

r? `@compiler-errors`

fixes  rust-lang#121404

cc rust-lang#116652

Author: bors

compiler/rustc_data_structures/src/obligation_forest/mod.rs

@@ -359,7 +359,10 @@ impl<O: ForestObligation> ObligationForest<O> {
             Entry::Vacant(v) => {
                 let obligation_tree_id = match parent {
                     Some(parent_index) => self.nodes[parent_index].obligation_tree_id,
-                    None => self.obligation_tree_id_generator.next().unwrap(),
+                    // FIXME(type_alias_impl_trait): with `#[defines]` attributes required to define hidden
+                    // types we can convert this back to a `next` method call, as this function shouldn't be
+                    // defining a hidden type anyway.
+                    None => Iterator::next(&mut self.obligation_tree_id_generator).unwrap(),
                 };
 
                 let already_failed = parent.is_some()

compiler/rustc_hir_typeck/src/callee.rs

@@ -627,7 +627,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return;
             };
 
-            let pick = self.confirm_method(
+            let pick = self.confirm_method_for_diagnostic(
                 call_expr.span,
                 callee_expr,
                 call_expr,

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1422,7 +1422,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let impl_ty = self.normalize(span, tcx.type_of(impl_def_id).instantiate(tcx, args));
             let self_ty = self.normalize(span, self_ty);
             match self.at(&self.misc(span), self.param_env).eq(
-                DefineOpaqueTypes::No,
+                DefineOpaqueTypes::Yes,
                 impl_ty,
                 self_ty,
             ) {

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -499,7 +499,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
                 args,
             })),
         );
-        match self.at(&cause, self.param_env).sup(DefineOpaqueTypes::No, method_self_ty, self_ty) {
+        match self.at(&cause, self.param_env).sup(DefineOpaqueTypes::Yes, method_self_ty, self_ty) {
             Ok(InferOk { obligations, value: () }) => {
                 self.register_predicates(obligations);
             }

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -1473,6 +1473,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         }
     }
 
+    #[instrument(level = "trace", skip(self, possibly_unsatisfied_predicates), ret)]
     fn consider_probe(
         &self,
         self_ty: Ty<'tcx>,
@@ -1483,20 +1484,31 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             Option<ObligationCause<'tcx>>,
         )>,
     ) -> ProbeResult {
-        debug!("consider_probe: self_ty={:?} probe={:?}", self_ty, probe);
-
         self.probe(|_| {
             // First check that the self type can be related.
-            let sub_obligations = match self.at(&ObligationCause::dummy(), self.param_env).sup(
-                DefineOpaqueTypes::No,
-                probe.xform_self_ty,
-                self_ty,
-            ) {
-                Ok(InferOk { obligations, value: () }) => obligations,
-                Err(err) => {
-                    debug!("--> cannot relate self-types {:?}", err);
-                    return ProbeResult::NoMatch;
+            let sub_obligations = match self_ty.kind() {
+                // HACK: opaque types will match anything for which their bounds hold.
+                // Thus we need to prevent them from trying to match the `&_` autoref
+                // candidates that get created for `&self` trait methods.
+                ty::Alias(ty::Opaque, alias_ty)
+                    if self.infcx.can_define_opaque_ty(alias_ty.def_id) =>
+                {
+                    if !probe.xform_self_ty.is_ty_var() {
+                        return ProbeResult::NoMatch;
+                    }
+                    vec![]
                 }
+                _ => match self.at(&ObligationCause::dummy(), self.param_env).sup(
+                    DefineOpaqueTypes::Yes,
+                    probe.xform_self_ty,
+                    self_ty,
+                ) {
+                    Ok(InferOk { obligations, value: () }) => obligations,
+                    Err(err) => {
+                        debug!("--> cannot relate self-types {:?}", err);
+                        return ProbeResult::NoMatch;
+                    }
+                },
             };
 
             let mut result = ProbeResult::Match;

compiler/rustc_middle/src/traits/query.rs

@@ -162,7 +162,7 @@ pub struct CandidateStep<'tcx> {
 
 #[derive(Copy, Clone, Debug, HashStable)]
 pub struct MethodAutoderefStepsResult<'tcx> {
-    /// The valid autoderef steps that could be find.
+    /// The valid autoderef steps that could be found.
     pub steps: &'tcx [CandidateStep<'tcx>],
     /// If Some(T), a type autoderef reported an error on.
     pub opt_bad_ty: Option<&'tcx MethodAutoderefBadTy<'tcx>>,

tests/ui/impl-trait/issues/issue-70877.rs

@@ -27,7 +27,9 @@ fn ham() -> Foo {
 
 fn oof(_: Foo) -> impl std::fmt::Debug {
     let mut bar = ham();
-    let func = bar.next().unwrap();
+    // Need to UFC invoke `Iterator::next`,
+    // as otherwise the hidden type gets constrained to `&mut _`
+    let func = Iterator::next(&mut bar).unwrap();
     return func(&"oof"); //~ ERROR opaque type's hidden type cannot be another opaque type
 }
 

tests/ui/impl-trait/issues/issue-70877.stderr

@@ -1,5 +1,5 @@
 error: opaque type's hidden type cannot be another opaque type from the same scope
-  --> $DIR/issue-70877.rs:31:12
+  --> $DIR/issue-70877.rs:33:12
    |
 LL |     return func(&"oof");
    |            ^^^^^^^^^^^^ one of the two opaque types used here has to be outside its defining scope

tests/ui/impl-trait/method-resolution.rs

@@ -0,0 +1,26 @@
+//! Since there is only one possible `bar` method, we invoke it and subsequently
+//! constrain `foo`'s RPIT to `u32`.
+
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ check-pass
+
+trait Trait {}
+
+impl Trait for u32 {}
+
+struct Bar<T>(T);
+
+impl Bar<u32> {
+    fn bar(self) {}
+}
+
+fn foo(x: bool) -> Bar<impl Sized> {
+    if x {
+        let x = foo(false);
+        x.bar();
+    }
+    todo!()
+}
+
+fn main() {}

tests/ui/impl-trait/method-resolution2.next.stderr

@@ -0,0 +1,20 @@
+error[E0034]: multiple applicable items in scope
+  --> $DIR/method-resolution2.rs:25:11
+   |
+LL |         x.bar();
+   |           ^^^ multiple `bar` found
+   |
+note: candidate #1 is defined in an impl for the type `Bar<T>`
+  --> $DIR/method-resolution2.rs:19:5
+   |
+LL |     fn bar(self) {}
+   |     ^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `Bar<u32>`
+  --> $DIR/method-resolution2.rs:15:5
+   |
+LL |     fn bar(self) {}
+   |     ^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0034`.