introduce a separate set of types for finalized proof trees

Author: BoxyUwU

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

@@ -2,7 +2,7 @@ use super::{CanonicalInput, Certainty, Goal, NoSolution, QueryInput, QueryResult
 use crate::ty;
 use std::fmt::{Debug, Write};
 
-#[derive(Eq, PartialEq, Hash, HashStable)]
+#[derive(Eq, PartialEq, Debug, Hash, HashStable)]
 pub enum CacheHit {
  Provisional,
  Global,
@@ -11,16 +11,16 @@ pub enum CacheHit {
 #[derive(Eq, PartialEq, Hash, HashStable)]
 pub struct GoalEvaluation<'tcx> {
  pub uncanonicalized_goal: Goal<'tcx, ty::Predicate<'tcx>>,
- pub canonicalized_goal: Option<CanonicalInput<'tcx>>,
-
- /// To handle coinductive cycles we can end up re-evaluating a goal
- /// multiple times with different results for a nested goal. Each rerun
- /// is represented as an entry in this vec.
- pub evaluation_steps: Vec<GoalEvaluationStep<'tcx>>,
+ pub canonicalized_goal: CanonicalInput<'tcx>,
 
- pub cache_hit: Option<CacheHit>,
+ pub kind: GoalEvaluationKind<'tcx>,
 
- pub result: Option<QueryResult<'tcx>>,
+ pub result: QueryResult<'tcx>,
+}
+#[derive(Eq, PartialEq, Hash, HashStable)]
+pub enum GoalEvaluationKind<'tcx> {
+ CacheHit(CacheHit),
+ Uncached { revisions: Vec<GoalEvaluationStep<'tcx>> },
 }
 impl Debug for GoalEvaluation<'_> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -31,7 +31,7 @@ impl Debug for GoalEvaluation<'_> {
 #[derive(Eq, PartialEq, Hash, HashStable)]
 pub struct AddedGoalsEvaluation<'tcx> {
  pub evaluations: Vec<Vec<GoalEvaluation<'tcx>>>,
- pub result: Option<Result<Certainty, NoSolution>>,
+ pub result: Result<Certainty, NoSolution>,
 }
 impl Debug for AddedGoalsEvaluation<'_> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -46,7 +46,7 @@ pub struct GoalEvaluationStep<'tcx> {
  pub nested_goal_evaluations: Vec<AddedGoalsEvaluation<'tcx>>,
  pub candidates: Vec<GoalCandidate<'tcx>>,
 
- pub result: Option<QueryResult<'tcx>>,
+ pub result: QueryResult<'tcx>,
 }
 impl Debug for GoalEvaluationStep<'_> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -58,9 +58,14 @@ impl Debug for GoalEvaluationStep<'_> {
 pub struct GoalCandidate<'tcx> {
  pub nested_goal_evaluations: Vec<AddedGoalsEvaluation<'tcx>>,
  pub candidates: Vec<GoalCandidate<'tcx>>,
-
- pub name: Option<String>,
- pub result: Option<QueryResult<'tcx>>,
+ pub kind: CandidateKind<'tcx>,
+}
+#[derive(Eq, PartialEq, Debug, Hash, HashStable)]
+pub enum CandidateKind<'tcx> {
+ /// Probe entered when normalizing the self ty during candidate assembly
+ NormalizedSelfTyAssembly,
+ /// A normal candidate for proving a goal
+ Candidate { name: String, result: QueryResult<'tcx> },
 }
 impl Debug for GoalCandidate<'_> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -97,19 +102,23 @@ impl ProofTreeFormatter<'_, '_> {
  writeln!(f, "GOAL: {:?}", goal.uncanonicalized_goal)?;
  writeln!(f, "CANONICALIZED: {:?}", goal.canonicalized_goal)?;
 
- match goal.cache_hit {
- Some(CacheHit::Global) => writeln!(f, "GLOBAL CACHE HIT: {:?}", goal.result),
- Some(CacheHit::Provisional) => writeln!(f, "PROVISIONAL CACHE HIT: {:?}", goal.result),
- None => {
- for (n, step) in goal.evaluation_steps.iter().enumerate() {
+ match &goal.kind {
+ GoalEvaluationKind::CacheHit(CacheHit::Global) => {
+ writeln!(f, "GLOBAL CACHE HIT: {:?}", goal.result)
+ }
+ GoalEvaluationKind::CacheHit(CacheHit::Provisional) => {
+ writeln!(f, "PROVISIONAL CACHE HIT: {:?}", goal.result)
+ }
+ GoalEvaluationKind::Uncached { revisions } => {
+ for (n, step) in revisions.iter().enumerate() {
  let f = &mut *self.f;
- writeln!(f, "REVISION {n}: {:?}", step.result.unwrap())?;
+ writeln!(f, "REVISION {n}: {:?}", step.result)?;
  let mut f = self.nested();
  f.format_evaluation_step(step)?;
  }
 
  let f = &mut *self.f;
- writeln!(f, "RESULT: {:?}", goal.result.unwrap())
+ writeln!(f, "RESULT: {:?}", goal.result)
  }
  }
  }
@@ -136,12 +145,14 @@ impl ProofTreeFormatter<'_, '_> {
  fn format_candidate(&mut self, candidate: &GoalCandidate<'_>) -> std::fmt::Result {
  let f = &mut *self.f;
 
- match (candidate.name.as_ref(), candidate.result) {
- (Some(name), Some(result)) => writeln!(f, "CANDIDATE {}: {:?}", name, result,)?,
- (None, None) => writeln!(f, "MISC PROBE")?,
- (None, Some(_)) => unreachable!("unexpected probe with no name but a result"),
- (Some(_), None) => unreachable!("unexpected probe with a name but no candidate"),
- };
+ match &candidate.kind {
+ CandidateKind::NormalizedSelfTyAssembly => {
+ writeln!(f, "NORMALIZING SELF TY FOR ASSEMBLY:")
+ }
+ CandidateKind::Candidate { name, result } => {
+ writeln!(f, "CANDIDATE {}: {:?}", name, result)
+ }
+ }?;
 
  let mut f = self.nested();
  for candidate in &candidate.candidates {
@@ -159,7 +170,7 @@ impl ProofTreeFormatter<'_, '_> {
  nested_goal_evaluation: &AddedGoalsEvaluation<'_>,
  ) -> std::fmt::Result {
  let f = &mut *self.f;
- writeln!(f, "TRY_EVALUATE_ADDED_GOALS: {:?}", nested_goal_evaluation.result.unwrap())?;
+ writeln!(f, "TRY_EVALUATE_ADDED_GOALS: {:?}", nested_goal_evaluation.result)?;
 
  for (n, revision) in nested_goal_evaluation.evaluations.iter().enumerate() {
  let f = &mut *self.f;

compiler/rustc_trait_selection/src/solve/alias_relate.rs

@@ -1,5 +1,6 @@
 use super::{EvalCtxt, SolverMode};
 use rustc_infer::traits::query::NoSolution;
+use rustc_middle::traits::solve::inspect::CandidateKind;
 use rustc_middle::traits::solve::{Certainty, Goal, QueryResult};
 use rustc_middle::ty;
 
@@ -109,12 +110,12 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  direction: ty::AliasRelationDirection,
  invert: Invert,
  ) -> QueryResult<'tcx> {
- self.probe_candidate(
+ self.probe(
  |ecx| {
  ecx.normalizes_to_inner(param_env, alias, other, direction, invert)?;
  ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
  },
- || "normalizes-to".into(),
+ |r| CandidateKind::Candidate { name: "normalizes-to".into(), result: *r },
  )
  }
 
@@ -156,7 +157,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  alias_rhs: ty::AliasTy<'tcx>,
  direction: ty::AliasRelationDirection,
  ) -> QueryResult<'tcx> {
- self.probe_candidate(
+ self.probe(
  |ecx| {
  match direction {
  ty::AliasRelationDirection::Equate => {
@@ -169,7 +170,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
 
  ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
  },
- || "substs relate".into(),
+ |r| CandidateKind::Candidate { name: "substs relate".into(), result: *r },
  )
  }
 
@@ -180,7 +181,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  rhs: ty::Term<'tcx>,
  direction: ty::AliasRelationDirection,
  ) -> QueryResult<'tcx> {
- self.probe_candidate(
+ self.probe(
  |ecx| {
  ecx.normalizes_to_inner(
  param_env,
@@ -198,7 +199,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  )?;
  ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
  },
- || "bidir normalizes-to".into(),
+ |r| CandidateKind::Candidate { name: "bidir normalizes-to".into(), result: *r },
  )
  }
 }

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

@@ -8,6 +8,7 @@ use rustc_hir::def_id::DefId;
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::util::elaborate;
 use rustc_infer::traits::Reveal;
+use rustc_middle::traits::solve::inspect::CandidateKind;
 use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, MaybeCause, QueryResult};
 use rustc_middle::ty::fast_reject::TreatProjections;
 use rustc_middle::ty::TypeFoldable;
@@ -336,37 +337,40 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  return
  };
 
- let normalized_self_candidates: Result<_, NoSolution> = self.probe(|ecx| {
- ecx.with_incremented_depth(
- |ecx| {
- let result = ecx.evaluate_added_goals_and_make_canonical_response(
- Certainty::Maybe(MaybeCause::Overflow),
- )?;
- Ok(vec![Candidate { source: CandidateSource::BuiltinImpl, result }])
- },
- |ecx| {
- let normalized_ty = ecx.next_ty_infer();
- let normalizes_to_goal = goal.with(
- tcx,
- ty::Binder::dummy(ty::ProjectionPredicate {
- projection_ty,
- term: normalized_ty.into(),
- }),
- );
- ecx.add_goal(normalizes_to_goal);
- let _ = ecx.try_evaluate_added_goals().inspect_err(|_| {
- debug!("self type normalization failed");
- })?;
- let normalized_ty = ecx.resolve_vars_if_possible(normalized_ty);
- debug!(?normalized_ty, "self type normalized");
- // NOTE: Alternatively we could call `evaluate_goal` here and only
- // have a `Normalized` candidate. This doesn't work as long as we
- // use `CandidateSource` in winnowing.
- let goal = goal.with(tcx, goal.predicate.with_self_ty(tcx, normalized_ty));
- Ok(ecx.assemble_and_evaluate_candidates(goal))
- },
- )
- });
+ let normalized_self_candidates: Result<_, NoSolution> = self.probe(
+ |ecx| {
+ ecx.with_incremented_depth(
+ |ecx| {
+ let result = ecx.evaluate_added_goals_and_make_canonical_response(
+ Certainty::Maybe(MaybeCause::Overflow),
+ )?;
+ Ok(vec![Candidate { source: CandidateSource::BuiltinImpl, result }])
+ },
+ |ecx| {
+ let normalized_ty = ecx.next_ty_infer();
+ let normalizes_to_goal = goal.with(
+ tcx,
+ ty::Binder::dummy(ty::ProjectionPredicate {
+ projection_ty,
+ term: normalized_ty.into(),
+ }),
+ );
+ ecx.add_goal(normalizes_to_goal);
+ let _ = ecx.try_evaluate_added_goals().inspect_err(|_| {
+ debug!("self type normalization failed");
+ })?;
+ let normalized_ty = ecx.resolve_vars_if_possible(normalized_ty);
+ debug!(?normalized_ty, "self type normalized");
+ // NOTE: Alternatively we could call `evaluate_goal` here and only
+ // have a `Normalized` candidate. This doesn't work as long as we
+ // use `CandidateSource` in winnowing.
+ let goal = goal.with(tcx, goal.predicate.with_self_ty(tcx, normalized_ty));
+ Ok(ecx.assemble_and_evaluate_candidates(goal))
+ },
+ )
+ },
+ |_| CandidateKind::NormalizedSelfTyAssembly,
+ );
 
  if let Ok(normalized_self_candidates) = normalized_self_candidates {
  candidates.extend(normalized_self_candidates);

compiler/rustc_trait_selection/src/solve/eval_ctxt.rs

@@ -9,6 +9,7 @@ use rustc_infer::infer::{
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
+use rustc_middle::traits::solve::inspect::CandidateKind;
 use rustc_middle::traits::solve::{
  CanonicalInput, CanonicalResponse, Certainty, MaybeCause, PredefinedOpaques,
  PredefinedOpaquesData, QueryResult,
@@ -78,7 +79,7 @@ pub struct EvalCtxt<'a, 'tcx> {
  inspect: ProofTreeBuilder<'tcx>,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, HashStable)]
 pub(super) enum IsNormalizesToHack {
  Yes,
  No,
@@ -157,7 +158,7 @@ impl<'tcx> InferCtxtEvalExt<'tcx> for InferCtxt<'tcx> {
  };
  let result = ecx.evaluate_goal(IsNormalizesToHack::No, goal);
 
- if let Some(tree) = ecx.inspect.into_proof_tree() {
+ if let Some(tree) = ecx.inspect.finalize() {
  println!("{:?}", tree);
  }
 
@@ -509,7 +510,13 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
 }
 
 impl<'tcx> EvalCtxt<'_, 'tcx> {
- pub(super) fn probe<T>(&mut self, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> T) -> T {
+ /// `probe_kind` is only called when proof tree building is enabled so it can be
+ /// as expensive as necessary to output the desired information.
+ pub(super) fn probe<T>(
+ &mut self,
+ f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> T,
+ probe_kind: impl FnOnce(&T) -> CandidateKind<'tcx>,
+ ) -> T {
  let mut ecx = EvalCtxt {
  infcx: self.infcx,
  var_values: self.var_values,
@@ -521,23 +528,14 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  inspect: self.inspect.new_goal_candidate(),
  };
  let r = self.infcx.probe(|_| f(&mut ecx));
- self.inspect.goal_candidate(ecx.inspect);
+ if !self.inspect.is_noop() {
+ let cand_kind = probe_kind(&r);
+ ecx.inspect.candidate_kind(cand_kind);
+ self.inspect.goal_candidate(ecx.inspect);
+ }
  r
  }
 
- pub(super) fn probe_candidate(
- &mut self,
- f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> QueryResult<'tcx>,
- mut name: impl FnMut() -> String,
- ) -> QueryResult<'tcx> {
- self.probe(|ecx| {
- let result = f(ecx);
- ecx.inspect.candidate_name(&mut name);
- ecx.inspect.query_result(result);
- result
- })
- }
-
  pub(super) fn tcx(&self) -> TyCtxt<'tcx> {
  self.infcx.tcx
  }
@@ -858,7 +856,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  ecx.add_item_bounds_for_hidden_type(candidate_key, param_env, candidate_ty);
  ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
  },
- || "opaque type storage".into(),
+ |r| CandidateKind::Candidate { name: "opaque type storage".into(), result: *r },
  ));
  }
  values