consistently return OpaquesAccessed from probes to signal why they error

Author: jdonszelmann

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

@@ -9,7 +9,7 @@ use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::search_graph::CandidateHeadUsages;
-use rustc_type_ir::solve::{AliasBoundKind, SizedTraitKind};
+use rustc_type_ir::solve::{AliasBoundKind, NoSolutionOrOpaquesAccessed, SizedTraitKind};
 use rustc_type_ir::{
     self as ty, AliasTy, Interner, MayBeErased, TypeFlags, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
@@ -161,7 +161,7 @@ where
                 })
             });
 
-        match result {
+        match result.map_err(Into::into) {
             Ok(result) => Ok(Candidate { source: source.get(), result, head_usages }),
             Err(NoSolution) => Err(head_usages),
         }
@@ -683,7 +683,7 @@ where
         goal: Goal<I, G>,
         candidates: &mut Vec<Candidate<I>>,
     ) {
-        let _res = self.probe(|_| ProbeKind::NormalizedSelfTyAssembly).enter(|ecx| {
+        let res = self.probe(|_| ProbeKind::NormalizedSelfTyAssembly).enter(|ecx| {
             ecx.assemble_alias_bound_candidates_recur(
                 goal.predicate.self_ty(),
                 goal,
@@ -692,9 +692,14 @@ where
             );
             Ok(())
         });
+
         // always returns Ok
-        // TODO: separate path for probes erroring because of accessing opaques
-        // assert!(res.is_ok());
+        match res {
+            Ok(_) | Err(NoSolutionOrOpaquesAccessed::OpaquesAccessed) => {}
+            Err(NoSolutionOrOpaquesAccessed::NoSolution(NoSolution)) => {
+                unreachable!()
+            }
+        }
     }
 
     /// For some deeply nested `<T>::A::B::C::D` rigid associated type,

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

@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 
 use rustc_type_ir::search_graph::CandidateHeadUsages;
-use rustc_type_ir::solve::{AccessedOpaques, CanonicalResponse};
+use rustc_type_ir::solve::{AccessedOpaques, CanonicalResponse, NoSolutionOrOpaquesAccessed};
 use rustc_type_ir::{InferCtxtLike, Interner};
 use tracing::{instrument, warn};
 
@@ -31,11 +31,11 @@ where
     pub(in crate::solve) fn enter_single_candidate(
         self,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> Result<T, NoSolution>,
-    ) -> (Result<T, NoSolution>, CandidateHeadUsages) {
+    ) -> (Result<T, NoSolutionOrOpaquesAccessed>, CandidateHeadUsages) {
         let mut candidate_usages = CandidateHeadUsages::default();
 
         if self.ecx.opaque_accesses.should_bail() {
-            return (Err(NoSolution), candidate_usages);
+            return (Err(NoSolutionOrOpaquesAccessed::OpaquesAccessed), candidate_usages);
         }
 
         self.ecx.search_graph.enter_single_candidate();
@@ -50,27 +50,27 @@ where
     pub(in crate::solve) fn enter(
         self,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> Result<T, NoSolution>,
-    ) -> Result<T, NoSolution> {
+    ) -> Result<T, NoSolutionOrOpaquesAccessed> {
         let nested_goals = self.ecx.nested_goals.clone();
         self.enter_inner(f, nested_goals)
     }
 
     pub(in crate::solve) fn enter_without_propagated_nested_goals(
         self,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> Result<T, NoSolution>,
-    ) -> Result<T, NoSolution> {
+    ) -> Result<T, NoSolutionOrOpaquesAccessed> {
         self.enter_inner(f, Default::default())
     }
 
     pub(in crate::solve) fn enter_inner(
         self,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> Result<T, NoSolution>,
         propagated_nested_goals: Vec<(GoalSource, Goal<I, I::Predicate>, Option<GoalStalledOn<I>>)>,
-    ) -> Result<T, NoSolution> {
+    ) -> Result<T, NoSolutionOrOpaquesAccessed> {
         let ProbeCtxt { ecx: outer, probe_kind, _result } = self;
 
         if outer.opaque_accesses.should_bail() {
-            return Err(NoSolution);
+            return Err(NoSolutionOrOpaquesAccessed::OpaquesAccessed);
         }
 
         let delegate = outer.delegate;
@@ -103,7 +103,7 @@ where
 
         outer.opaque_accesses.update(nested.opaque_accesses);
 
-        r
+        r.map_err(Into::into)
     }
 }
 
@@ -128,7 +128,7 @@ where
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         let (result, head_usages) = self.cx.enter_single_candidate(f);
-        result.map(|result| Candidate { source: self.source, result, head_usages })
+        Ok(Candidate { source: self.source, result: result?, head_usages })
     }
 }
 

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

@@ -76,13 +76,17 @@ where
                         None
                     },
                     |ecx| {
-                        ecx.probe(|&result| ProbeKind::RigidAlias { result }).enter(|this| {
-                            this.structurally_instantiate_normalizes_to_term(
-                                goal,
-                                goal.predicate.alias,
-                            );
-                            this.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
-                        })
+                        ecx.probe(|&result| ProbeKind::RigidAlias { result })
+                            .enter(|this| {
+                                this.structurally_instantiate_normalizes_to_term(
+                                    goal,
+                                    goal.predicate.alias,
+                                );
+                                this.evaluate_added_goals_and_make_canonical_response(
+                                    Certainty::Yes,
+                                )
+                            })
+                            .map_err(Into::into)
                     },
                 )
             }

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -854,7 +854,7 @@ where
             },
         );
 
-        match result {
+        match result.map_err(Into::into) {
             Ok(resp) => resp,
             Err(NoSolution) => vec![],
         }

compiler/rustc_type_ir/src/solve/mod.rs

@@ -32,6 +32,33 @@ pub type QueryResult<I> = Result<CanonicalResponse<I>, NoSolution>;
 #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
 pub struct NoSolution;
 
+pub enum NoSolutionOrOpaquesAccessed {
+    NoSolution(NoSolution),
+    /// A bit like [`NoSolution`], but for functions that normally cannot fail *unless* they accessed
+    /// opaues. (See [`TypingMode::ErasedNotCoherence`]). Getting `OpaquesAccessed` doesn't mean there
+    /// truly is no solution. It just means that we want to bail out of the current query as fast as
+    /// possible, possibly by returning `NoSolution` if that's fastest. This is okay because when you get
+    /// `OpaquesAccessed` we're guaranteed that we're going to retry this query in the original typing
+    /// mode to get the correct answer.
+    OpaquesAccessed,
+}
+
+/// This conversion is sound, because even in we're in `OpaquesAccessed`,
+/// we're going to retry so `NoSolution` is a valid response to give..
+impl From<NoSolutionOrOpaquesAccessed> for NoSolution {
+    fn from(
+        (NoSolutionOrOpaquesAccessed::NoSolution(_) | NoSolutionOrOpaquesAccessed::OpaquesAccessed): NoSolutionOrOpaquesAccessed,
+    ) -> Self {
+        NoSolution
+    }
+}
+
+impl From<NoSolution> for NoSolutionOrOpaquesAccessed {
+    fn from(value: NoSolution) -> Self {
+        Self::NoSolution(value)
+    }
+}
+
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 #[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic)]
 #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]