self-review

Author: lcnr

compiler/rustc_middle/src/traits/solve/inspect.rs

@@ -50,8 +50,8 @@ pub enum CacheHit {
 
 /// When evaluating the root goals we also store the
 /// original values for the `CanonicalVarValues` of the
-/// canonicalized goal to map any [CanonicalState]
-/// from the `InferCtxt` local to the solver query to
+/// canonicalized goal. We use this to map any [CanonicalState]
+/// from the local `InferCtxt` of the solver query to
 /// the `InferCtxt` of the caller.
 #[derive(Eq, PartialEq)]
 pub enum GoalEvaluationKind<'tcx> {
@@ -131,8 +131,8 @@ pub enum ProbeStep<'tcx> {
 }
 
 /// What kind of probe we're in. In case the probe represents a candidate, or
-/// the final result - via [ProbeKind::Root] - we also store the result for
-/// the candidate.
+/// the final result of the current goal - via [ProbeKind::Root] - we also
+/// store the [QueryResult].
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ProbeKind<'tcx> {
     /// The root inference context while proving a goal.

compiler/rustc_trait_selection/src/solve/inspect/analyse.rs

@@ -48,7 +48,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
     }
 
     /// Visit the nested goals of this candidate.
-    /// 
+    ///
     /// FIXME(@lcnr): we have to slightly adapt this API
     /// to also use it to compute the most relevant goal
     /// for fulfillment errors. Will do that once we actually
@@ -189,7 +189,7 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
                 infcx,
                 depth,
                 orig_values,
-                goal: root.uncanonicalized_goal,
+                goal: infcx.resolve_vars_if_possible(root.uncanonicalized_goal),
                 evaluation: root,
             },
             inspect::GoalEvaluationKind::Nested { .. } => unreachable!(),

compiler/rustc_trait_selection/src/solve/inspect/build.rs

@@ -18,12 +18,11 @@ use crate::solve::{self, inspect, EvalCtxt, GenerateProofTree};
 /// In case the current evaluation does not generate a proof
 /// tree, `state` is simply `None` and we avoid any work.
 ///
-/// The possible states the solver is in are represented via
+/// The possible states of the solver are represented via
 /// variants of [DebugSolver]. For any nested computation we call
 /// `ProofTreeBuilder::new_nested_computation_kind` which
-/// creates a new `ProofTreeBuilder` using the corresponding
-/// [DebugSolver] variant to temporarily replace the current one.
-/// Once that nested computation is done,
+/// creates a new `ProofTreeBuilder` to temporarily replace the
+/// current one. Once that nested computation is done,
 /// `ProofTreeBuilder::nested_computation_kind` is called
 /// to add the finished nested evaluation to the parent.
 ///

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -893,6 +893,11 @@ where
 
 /// Compute the `intercrate_ambiguity_causes` for the new solver using
 /// "proof trees".
+///
+/// This is a bit scuffed but seems to be good enough, at least
+/// when looking at UI tests. Given that it is only used to improve
+/// diagnostics this is good enough. We can always improve it once there
+/// are test cases where it is currently not enough.
 fn compute_intercrate_ambiguity_causes<'tcx>(
     infcx: &InferCtxt<'tcx>,
     obligations: &[PredicateObligation<'tcx>],
@@ -976,7 +981,6 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a> {
                         Err(()) => {}
                         Ok(Ok(())) => warn!("expected an unknowable trait ref: {trait_ref:?}"),
                         Ok(Err(conflict)) => {
-                            let trait_ref = infcx.resolve_vars_if_possible(trait_ref);
                             if !trait_ref.references_error() {
                                 let self_ty = trait_ref.self_ty();
                                 let (trait_desc, self_desc) = with_no_trimmed_paths!({