Store goal source in InspectGoal

Author: compiler-errors

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

@@ -37,12 +37,13 @@ pub struct InspectGoal<'a, 'tcx> {
     orig_values: &'a [ty::GenericArg<'tcx>],
     goal: Goal<'tcx, ty::Predicate<'tcx>>,
     evaluation: &'a inspect::GoalEvaluation<'tcx>,
+    source: GoalSource,
 }
 
 pub struct InspectCandidate<'a, 'tcx> {
     goal: &'a InspectGoal<'a, 'tcx>,
     kind: inspect::ProbeKind<'tcx>,
-    nested_goals: Vec<inspect::CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>>,
+    nested_goals: Vec<(GoalSource, inspect::CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>)>,
     final_state: inspect::CanonicalState<'tcx, ()>,
     result: QueryResult<'tcx>,
 }
@@ -65,15 +66,15 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
             let param_env = self.goal.goal.param_env;
             let mut orig_values = self.goal.orig_values.to_vec();
             let mut instantiated_goals = vec![];
-            for goal in &self.nested_goals {
+            for &(source, goal) in &self.nested_goals {
                 let goal = canonical::instantiate_canonical_state(
                     infcx,
                     visitor.span(),
                     param_env,
                     &mut orig_values,
-                    *goal,
+                    goal,
                 );
-                instantiated_goals.push(goal);
+                instantiated_goals.push((source, goal));
             }
 
             let () = canonical::instantiate_canonical_state(
@@ -84,7 +85,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
                 self.final_state,
             );
 
-            for &goal in &instantiated_goals {
+            for (source, goal) in instantiated_goals {
                 let proof_tree = match goal.predicate.kind().no_bound_vars() {
                     Some(ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })) => {
                         let unconstrained_term = match term.unpack() {
@@ -127,6 +128,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
                     infcx,
                     self.goal.depth + 1,
                     &proof_tree.unwrap(),
+                    source,
                 )));
             }
         }
@@ -150,20 +152,27 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
         self.goal
     }
 
+    pub fn source(&self) -> GoalSource {
+        self.source
+    }
+
     pub fn result(&self) -> Result<Certainty, NoSolution> {
         self.evaluation.evaluation.result.map(|c| c.value.certainty)
     }
 
     fn candidates_recur(
         &'a self,
         candidates: &mut Vec<InspectCandidate<'a, 'tcx>>,
-        nested_goals: &mut Vec<inspect::CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>>,
+        nested_goals: &mut Vec<(
+            GoalSource,
+            inspect::CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>,
+        )>,
         probe: &inspect::Probe<'tcx>,
     ) {
         let num_candidates = candidates.len();
         for step in &probe.steps {
             match step {
-                &inspect::ProbeStep::AddGoal(_source, goal) => nested_goals.push(goal),
+                &inspect::ProbeStep::AddGoal(source, goal) => nested_goals.push((source, goal)),
                 inspect::ProbeStep::NestedProbe(ref probe) => {
                     // Nested probes have to prove goals added in their parent
                     // but do not leak them, so we truncate the added goals
@@ -250,6 +259,7 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
         infcx: &'a InferCtxt<'tcx>,
         depth: usize,
         root: &'a inspect::GoalEvaluation<'tcx>,
+        source: GoalSource,
     ) -> Self {
         match root.kind {
             inspect::GoalEvaluationKind::Root { ref orig_values } => InspectGoal {
@@ -258,6 +268,7 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
                 orig_values,
                 goal: root.uncanonicalized_goal.fold_with(&mut EagerResolver::new(infcx)),
                 evaluation: root,
+                source,
             },
             inspect::GoalEvaluationKind::Nested { .. } => unreachable!(),
         }
@@ -286,6 +297,6 @@ impl<'tcx> InferCtxt<'tcx> {
     ) -> V::Result {
         let (_, proof_tree) = self.evaluate_root_goal(goal, GenerateProofTree::Yes);
         let proof_tree = proof_tree.unwrap();
-        visitor.visit_goal(&InspectGoal::new(self, 0, &proof_tree))
+        visitor.visit_goal(&InspectGoal::new(self, 0, &proof_tree, GoalSource::Misc))
     }
 }