w

Author: lcnr

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -30,6 +30,7 @@ use rustc_span::edit_distance::{
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
 use rustc_trait_selection::error_reporting::infer::need_type_info::TypeAnnotationNeeded;
 use rustc_trait_selection::infer::InferCtxtExt as _;
+use rustc_trait_selection::solve::Goal;
 use rustc_trait_selection::traits::query::CanonicalMethodAutoderefStepsGoal;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use rustc_trait_selection::traits::query::method_autoderef::{
@@ -1872,7 +1873,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         }
     }
 
-    #[instrument(level = "trace", skip(self, possibly_unsatisfied_predicates), ret)]
+    #[instrument(level = "debug", skip(self, possibly_unsatisfied_predicates), ret)]
     fn consider_probe(
         &self,
         self_ty: Ty<'tcx>,
@@ -1884,15 +1885,17 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             Option<ObligationCause<'tcx>>,
         )>,
     ) -> ProbeResult {
-        debug!("consider_probe: self_ty={:?} probe={:?}", self_ty, probe);
-
         self.probe(|snapshot| {
             let outer_universe = self.universe();
 
             let mut result = ProbeResult::Match;
             let cause = &self.misc(self.span);
             let ocx = ObligationCtxt::new_with_diagnostics(self);
             ocx.register_obligations(instantiate_self_ty_obligations.iter().cloned());
+            let errors = ocx.select_where_possible();
+            if !errors.is_empty() {
+                unreachable!("unexpected autoderef error {errors:?}");
+            }
 
             let mut trait_predicate = None;
             let (mut xform_self_ty, mut xform_ret_ty);
@@ -2104,6 +2107,16 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 }
             }
 
+            if let Some(predicate) = trait_predicate
+                && self.infcx.next_trait_solver()
+            {
+                let goal = Goal { param_env: self.param_env, predicate };
+
+                if !self.infcx.goal_may_hold_opaque_types_jank(goal) {
+                    result = ProbeResult::NoMatch;
+                }
+            }
+
             if let ProbeResult::Match = result
                 && let Some(return_ty) = self.return_type
                 && let Some(mut xform_ret_ty) = xform_ret_ty
@@ -2150,13 +2163,15 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                         };
                         let ocx = ObligationCtxt::new(self);
                         let self_ty = ocx.register_infer_ok_obligations(ok);
-                        if !ocx.select_all_or_error().is_empty() {
-                            return false;
+                        if ocx.select_all_or_error().is_empty() {
+                            !self.resolve_vars_if_possible(self_ty).is_ty_var()
+                        } else {
+                            true
                         }
-
-                        !self.resolve_vars_if_possible(self_ty).is_ty_var()
                     }) {
+                        debug!("candidate constrains opaque --> reject");
                         result = ProbeResult::NoMatch;
+                        break;
                     }
                 }
             }

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -85,11 +85,22 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: Debug + TypeFoldable<TyCtxt<'tcx>>,
     {
+        let opaque_types = if self.next_trait_solver() {
+            self.inner
+                .borrow_mut()
+                .opaque_type_storage
+                .iter_opaque_types()
+                .map(|(k, v)| (k, v.ty))
+                .collect()
+        } else {
+            vec![]
+        };
+
         self.canonicalize_response(QueryResponse {
             var_values: inference_vars,
             region_constraints: QueryRegionConstraints::default(),
             certainty: Certainty::Proven, // Ambiguities are OK!
-            opaque_types: vec![],
+            opaque_types,
             value: answer,
         })
     }

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -194,7 +194,7 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    #[instrument(level = "debug", skip(self))]
+    #[instrument(level = "debug", skip(self), ret)]
     fn evaluate_root_goal(
         &self,
         goal: Goal<I, I::Predicate>,
@@ -206,6 +206,7 @@ where
         })
     }
 
+    #[instrument(level = "debug", skip(self), ret)]
     fn root_goal_may_hold_opaque_types_jank(
         &self,
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -381,6 +381,7 @@ where
 }
 
 /// The result of evaluating a goal.
+#[derive_where(Debug; I: Interner)]
 pub struct GoalEvaluation<I: Interner> {
     /// The goal we've evaluated. This is the input goal, but potentially with its
     /// inference variables resolved. This never applies any inference constraints

compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs

@@ -1,6 +1,6 @@
 use rustc_infer::traits::solve::Goal;
 use rustc_macros::extension;
-use rustc_middle::span_bug;
+use rustc_middle::{span_bug, ty};
 use rustc_next_trait_solver::solve::SolverDelegateEvalExt;
 
 use crate::infer::InferCtxt;
@@ -22,7 +22,7 @@ impl<'tcx> InferCtxt<'tcx> {
     /// for more details.
     fn predicate_may_hold_opaque_types_jank(&self, obligation: &PredicateObligation<'tcx>) -> bool {
         if self.next_trait_solver() {
-            <&SolverDelegate<'tcx>>::from(self).root_goal_may_hold_opaque_types_jank(Goal::new(
+            self.goal_may_hold_opaque_types_jank(Goal::new(
                 self.tcx,
                 obligation.param_env,
                 obligation.predicate,
@@ -32,6 +32,13 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 
+    /// See the comment on [OpaqueTypesJank](crate::solve::OpaqueTypesJank)
+    /// for more details.
+    fn goal_may_hold_opaque_types_jank(&self, goal: Goal<'tcx, ty::Predicate<'tcx>>) -> bool {
+        assert!(self.next_trait_solver());
+        <&SolverDelegate<'tcx>>::from(self).root_goal_may_hold_opaque_types_jank(goal)
+    }
+
     /// Evaluates whether the predicate can be satisfied in the given
     /// `ParamEnv`, and returns `false` if not certain. However, this is
     /// not entirely accurate if inference variables are involved.

tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.next.stderr

@@ -1,11 +1,15 @@
-error[E0277]: the trait bound `(): MyDebug` is not satisfied
+error[E0599]: no method named `my_debug` found for reference `&_` in the current scope
   --> $DIR/call_method_on_inherent_impl_on_rigid_type.rs:15:11
    |
 LL |         x.my_debug();
-   |           ^^^^^^^^ the trait `MyDebug` is not implemented for `()`
+   |           ^^^^^^^^ method not found in `&_`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+help: trait `MyDebug` which provides `my_debug` is implemented but not in scope; perhaps you want to import it
+   |
+LL + use MyDebug;
    |
-   = help: the trait `MyDebug` is implemented for `&()`
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0599`.

tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.rs

@@ -13,8 +13,7 @@ fn my_foo() -> impl std::fmt::Debug {
     if false {
         let x = &my_foo();
         x.my_debug();
-        //[current]~^ ERROR: no method named `my_debug`
-        //[next]~^^ ERROR: the trait bound `(): MyDebug` is not satisfied
+        //~^ ERROR: no method named `my_debug`
     }
     ()
 }

tests/ui/impl-trait/call_method_on_inherent_impl_ref.current.stderr renamed to tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.current.stderr

@@ -1,5 +1,5 @@
 error[E0599]: no method named `my_debug` found for opaque type `impl Debug` in the current scope
-  --> $DIR/call_method_on_inherent_impl_ref.rs:18:11
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:18:11
    |
 LL |     fn my_debug(&self);
    |        -------- the method is available for `&impl Debug` here
@@ -9,7 +9,7 @@ LL |         x.my_debug();
    |
    = help: items from traits can only be used if the trait is implemented and in scope
 note: `MyDebug` defines an item `my_debug`, perhaps you need to implement it
-  --> $DIR/call_method_on_inherent_impl_ref.rs:4:1
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:4:1
    |
 LL | trait MyDebug {
    | ^^^^^^^^^^^^^

tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.next.stderr

@@ -0,0 +1,19 @@
+error[E0599]: no method named `my_debug` found for type `_` in the current scope
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:18:11
+   |
+LL |     fn my_debug(&self);
+   |        -------- the method is available for `&_` here
+...
+LL |         x.my_debug();
+   |           ^^^^^^^^ method not found in `_`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `MyDebug` defines an item `my_debug`, perhaps you need to implement it
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:4:1
+   |
+LL | trait MyDebug {
+   | ^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.

tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.rs

@@ -0,0 +1,24 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+
+trait MyDebug {
+    fn my_debug(&self);
+}
+
+impl<T> MyDebug for &T
+where
+    T: std::fmt::Debug,
+{
+    fn my_debug(&self) {}
+}
+
+fn my_foo() -> impl std::fmt::Debug {
+    if false {
+        let x = my_foo();
+        x.my_debug();
+        //~^ ERROR no method named `my_debug` found
+    }
+    ()
+}
+
+fn main() {}