diff --git a/compiler/rustc_middle/src/traits/solve.rs b/compiler/rustc_middle/src/traits/solve.rs index 9d63d29185470..7bc227abfce68 100644 --- a/compiler/rustc_middle/src/traits/solve.rs +++ b/compiler/rustc_middle/src/traits/solve.rs @@ -1,7 +1,5 @@ use std::ops::ControlFlow; -use rustc_data_structures::intern::Interned; - use crate::infer::canonical::{CanonicalVarValues, QueryRegionConstraints}; use crate::traits::query::NoSolution; use crate::traits::{Canonical, DefiningAnchor}; @@ -9,12 +7,16 @@ use crate::ty::{ self, FallibleTypeFolder, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor, }; +use rustc_data_structures::intern::Interned; +use rustc_span::def_id::DefId; mod cache; pub mod inspect; pub use cache::{CacheData, EvaluationCache}; +use super::BuiltinImplSource; + /// A goal is a statement, i.e. `predicate`, we want to prove /// given some assumptions, i.e. `param_env`. /// @@ -230,8 +232,62 @@ impl<'tcx> TypeVisitable> for PredefinedOpaques<'tcx> { } } -#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, HashStable)] -pub enum IsNormalizesToHack { - Yes, - No, +/// Possible ways the given goal can be proven. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CandidateSource { + /// A user written impl. + /// + /// ## Examples + /// + /// ```rust + /// fn main() { + /// let x: Vec = Vec::new(); + /// // This uses the impl from the standard library to prove `Vec: Clone`. + /// let y = x.clone(); + /// } + /// ``` + Impl(DefId), + /// A builtin impl generated by the compiler. When adding a new special + /// trait, try to use actual impls whenever possible. Builtin impls should + /// only be used in cases where the impl cannot be manually be written. + /// + /// Notable examples are auto traits, `Sized`, and `DiscriminantKind`. + /// For a list of all traits with builtin impls, check out the + /// [`EvalCtxt::assemble_builtin_impl_candidates`] method. Not + BuiltinImpl(BuiltinImplSource), + /// An assumption from the environment. + /// + /// More precisely we've used the `n-th` assumption in the `param_env`. + /// + /// ## Examples + /// + /// ```rust + /// fn is_clone(x: T) -> (T, T) { + /// // This uses the assumption `T: Clone` from the `where`-bounds + /// // to prove `T: Clone`. + /// (x.clone(), x) + /// } + /// ``` + ParamEnv(usize), + /// If the self type is an alias type, e.g. an opaque type or a projection, + /// we know the bounds on that alias to hold even without knowing its concrete + /// underlying type. + /// + /// More precisely this candidate is using the `n-th` bound in the `item_bounds` of + /// the self type. + /// + /// ## Examples + /// + /// ```rust + /// trait Trait { + /// type Assoc: Clone; + /// } + /// + /// fn foo(x: ::Assoc) { + /// // We prove `::Assoc` by looking at the bounds on `Assoc` in + /// // in the trait definition. + /// let _y = x.clone(); + /// } + /// ``` + AliasBound, } diff --git a/compiler/rustc_middle/src/traits/solve/inspect.rs b/compiler/rustc_middle/src/traits/solve/inspect.rs index 4e2af3816ac65..33512b40b31a5 100644 --- a/compiler/rustc_middle/src/traits/solve/inspect.rs +++ b/compiler/rustc_middle/src/traits/solve/inspect.rs @@ -1,90 +1,94 @@ -use super::{ - CanonicalInput, Certainty, Goal, IsNormalizesToHack, NoSolution, QueryInput, QueryResult, -}; +use super::{CandidateSource, CanonicalInput, Certainty, Goal, NoSolution, QueryResult}; +use crate::infer::canonical::{Canonical, CanonicalVarValues}; use crate::ty; use format::ProofTreeFormatter; use std::fmt::{Debug, Write}; mod format; -#[derive(Eq, PartialEq, Debug, Hash, HashStable)] +#[derive(Debug, Clone, Eq, PartialEq, Hash, HashStable, TypeFoldable, TypeVisitable)] +pub struct State<'tcx, T> { + pub var_values: CanonicalVarValues<'tcx>, + pub data: T, +} +pub type CanonicalState<'tcx, T> = Canonical<'tcx, State<'tcx, T>>; + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum CacheHit { Provisional, Global, } -#[derive(Eq, PartialEq, Hash, HashStable)] -pub struct GoalEvaluation<'tcx> { - pub uncanonicalized_goal: Goal<'tcx, ty::Predicate<'tcx>>, - pub canonicalized_goal: CanonicalInput<'tcx>, +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum IsNormalizesToHack { + Yes, + No, +} - pub kind: GoalEvaluationKind<'tcx>, - pub is_normalizes_to_hack: IsNormalizesToHack, +pub struct RootGoalEvaluation<'tcx> { + pub goal: Goal<'tcx, ty::Predicate<'tcx>>, + pub orig_values: Vec>, + pub evaluation: CanonicalGoalEvaluation<'tcx>, pub returned_goals: Vec>>, +} +pub struct NestedGoalEvaluation<'tcx> { + pub goal: CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>, + pub orig_values: CanonicalState<'tcx, Vec>>, + pub is_normalizes_to_hack: IsNormalizesToHack, + pub evaluation: CanonicalGoalEvaluation<'tcx>, + pub returned_goals: Vec>>>, +} + +pub struct CanonicalGoalEvaluation<'tcx> { + pub goal: CanonicalInput<'tcx>, + pub data: GoalEvaluationData<'tcx>, pub result: QueryResult<'tcx>, } -#[derive(Eq, PartialEq, Hash, HashStable)] -pub enum GoalEvaluationKind<'tcx> { +pub enum GoalEvaluationData<'tcx> { CacheHit(CacheHit), Uncached { revisions: Vec> }, } -impl Debug for GoalEvaluation<'_> { +impl Debug for RootGoalEvaluation<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - ProofTreeFormatter::new(f).format_goal_evaluation(self) + ProofTreeFormatter::new(f).format_root_goal_evaluation(self) } } -#[derive(Eq, PartialEq, Hash, HashStable)] pub struct AddedGoalsEvaluation<'tcx> { - pub evaluations: Vec>>, + pub evaluations: Vec>>, pub result: Result, } -impl Debug for AddedGoalsEvaluation<'_> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - ProofTreeFormatter::new(f).format_nested_goal_evaluation(self) - } -} -#[derive(Eq, PartialEq, Hash, HashStable)] pub struct GoalEvaluationStep<'tcx> { - pub instantiated_goal: QueryInput<'tcx, ty::Predicate<'tcx>>, - - pub nested_goal_evaluations: Vec>, + pub added_goals_evaluations: Vec>, pub candidates: Vec>, pub result: QueryResult<'tcx>, } -impl Debug for GoalEvaluationStep<'_> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - ProofTreeFormatter::new(f).format_evaluation_step(self) - } -} -#[derive(Eq, PartialEq, Hash, HashStable)] pub struct GoalCandidate<'tcx> { - pub nested_goal_evaluations: Vec>, + pub added_goals_evaluations: Vec>, pub candidates: Vec>, - pub kind: CandidateKind<'tcx>, + pub kind: ProbeKind<'tcx>, } -#[derive(Eq, PartialEq, Debug, Hash, HashStable)] -pub enum CandidateKind<'tcx> { +#[derive(Debug, PartialEq, Eq)] +pub enum ProbeKind<'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> }, + /// Some candidate to prove the current goal. + /// + /// FIXME: Remove this in favor of always using more strongly typed variants. + MiscCandidate { name: &'static str, result: QueryResult<'tcx> }, + /// A candidate for proving a trait or alias-relate goal. + TraitCandidate { source: CandidateSource, result: QueryResult<'tcx> }, /// Used in the probe that wraps normalizing the non-self type for the unsize /// trait, which is also structurally matched on. UnsizeAssembly, /// During upcasting from some source object to target object type, used to /// do a probe to find out what projection type(s) may be used to prove that /// the source type upholds all of the target type's object bounds. - UpcastProbe, -} -impl Debug for GoalCandidate<'_> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - ProofTreeFormatter::new(f).format_candidate(self) - } + UpcastProjectionCompatibility, } diff --git a/compiler/rustc_middle/src/traits/solve/inspect/format.rs b/compiler/rustc_middle/src/traits/solve/inspect/format.rs index 8759fecb05a2d..fa89215d4451c 100644 --- a/compiler/rustc_middle/src/traits/solve/inspect/format.rs +++ b/compiler/rustc_middle/src/traits/solve/inspect/format.rs @@ -39,57 +39,84 @@ impl<'a, 'b> ProofTreeFormatter<'a, 'b> { func(&mut ProofTreeFormatter { f: &mut Indentor { f: self.f, on_newline: true } }) } - pub(super) fn format_goal_evaluation(&mut self, goal: &GoalEvaluation<'_>) -> std::fmt::Result { - let goal_text = match goal.is_normalizes_to_hack { - IsNormalizesToHack::Yes => "NORMALIZES-TO HACK GOAL", - IsNormalizesToHack::No => "GOAL", - }; - - writeln!(self.f, "{}: {:?}", goal_text, goal.uncanonicalized_goal)?; - writeln!(self.f, "CANONICALIZED: {:?}", goal.canonicalized_goal)?; - - match &goal.kind { - GoalEvaluationKind::CacheHit(CacheHit::Global) => { - writeln!(self.f, "GLOBAL CACHE HIT: {:?}", goal.result) - } - GoalEvaluationKind::CacheHit(CacheHit::Provisional) => { - writeln!(self.f, "PROVISIONAL CACHE HIT: {:?}", goal.result) - } - GoalEvaluationKind::Uncached { revisions } => { - for (n, step) in revisions.iter().enumerate() { - writeln!(self.f, "REVISION {n}: {:?}", step.result)?; - self.nested(|this| this.format_evaluation_step(step))?; + pub(super) fn format_root_goal_evaluation( + &mut self, + eval: &RootGoalEvaluation<'_>, + ) -> std::fmt::Result { + writeln!(self.f, "ROOT GOAL: {:?}", eval.goal)?; + self.nested(|this| this.format_canonical_goal_evaluation(&eval.evaluation))?; + if eval.returned_goals.len() > 0 { + writeln!(self.f, "NESTED GOALS ADDED TO CALLER: [")?; + self.nested(|this| { + for goal in eval.returned_goals.iter() { + writeln!(this.f, "ADDED GOAL: {goal:?},")?; } - writeln!(self.f, "RESULT: {:?}", goal.result) - } - }?; + Ok(()) + })?; + + writeln!(self.f, "]") + } else { + Ok(()) + } + } - if goal.returned_goals.len() > 0 { + pub(super) fn format_nested_goal_evaluation( + &mut self, + eval: &NestedGoalEvaluation<'_>, + ) -> std::fmt::Result { + let goal_text = match eval.is_normalizes_to_hack { + IsNormalizesToHack::Yes => "NORMALIZES-TO HACK GOAL", + IsNormalizesToHack::No => "NESTED GOAL", + }; + writeln!(self.f, "{}: {:?}", goal_text, eval.goal)?; + self.nested(|this| this.format_canonical_goal_evaluation(&eval.evaluation))?; + if eval.returned_goals.len() > 0 { writeln!(self.f, "NESTED GOALS ADDED TO CALLER: [")?; self.nested(|this| { - for goal in goal.returned_goals.iter() { + for goal in eval.returned_goals.iter() { writeln!(this.f, "ADDED GOAL: {goal:?},")?; } Ok(()) })?; - writeln!(self.f, "]")?; + writeln!(self.f, "]") + } else { + Ok(()) } + } - Ok(()) + pub(super) fn format_canonical_goal_evaluation( + &mut self, + eval: &CanonicalGoalEvaluation<'_>, + ) -> std::fmt::Result { + writeln!(self.f, "GOAL: {:?}", eval.goal)?; + + match &eval.data { + GoalEvaluationData::CacheHit(CacheHit::Global) => { + writeln!(self.f, "GLOBAL CACHE HIT: {:?}", eval.result) + } + GoalEvaluationData::CacheHit(CacheHit::Provisional) => { + writeln!(self.f, "PROVISIONAL CACHE HIT: {:?}", eval.result) + } + GoalEvaluationData::Uncached { revisions } => { + for (n, step) in revisions.iter().enumerate() { + writeln!(self.f, "REVISION {n}: {:?}", step.result)?; + self.format_evaluation_step(step)?; + } + writeln!(self.f, "RESULT: {:?}", eval.result) + } + } } pub(super) fn format_evaluation_step( &mut self, evaluation_step: &GoalEvaluationStep<'_>, ) -> std::fmt::Result { - writeln!(self.f, "INSTANTIATED: {:?}", evaluation_step.instantiated_goal)?; - for candidate in &evaluation_step.candidates { self.nested(|this| this.format_candidate(candidate))?; } - for nested in &evaluation_step.nested_goal_evaluations { - self.nested(|this| this.format_nested_goal_evaluation(nested))?; + for nested in &evaluation_step.added_goals_evaluations { + self.nested(|this| this.format_added_goals_evaluation(nested))?; } Ok(()) @@ -97,42 +124,45 @@ impl<'a, 'b> ProofTreeFormatter<'a, 'b> { pub(super) fn format_candidate(&mut self, candidate: &GoalCandidate<'_>) -> std::fmt::Result { match &candidate.kind { - CandidateKind::NormalizedSelfTyAssembly => { + ProbeKind::NormalizedSelfTyAssembly => { writeln!(self.f, "NORMALIZING SELF TY FOR ASSEMBLY:") } - CandidateKind::UnsizeAssembly => { + ProbeKind::UnsizeAssembly => { writeln!(self.f, "ASSEMBLING CANDIDATES FOR UNSIZING:") } - CandidateKind::UpcastProbe => { + ProbeKind::UpcastProjectionCompatibility => { writeln!(self.f, "PROBING FOR PROJECTION COMPATIBILITY FOR UPCASTING:") } - CandidateKind::Candidate { name, result } => { + ProbeKind::MiscCandidate { name, result } => { writeln!(self.f, "CANDIDATE {name}: {result:?}") } + ProbeKind::TraitCandidate { source, result } => { + writeln!(self.f, "CANDIDATE {source:?}: {result:?}") + } }?; self.nested(|this| { for candidate in &candidate.candidates { this.format_candidate(candidate)?; } - for nested in &candidate.nested_goal_evaluations { - this.format_nested_goal_evaluation(nested)?; + for nested in &candidate.added_goals_evaluations { + this.format_added_goals_evaluation(nested)?; } Ok(()) }) } - pub(super) fn format_nested_goal_evaluation( + pub(super) fn format_added_goals_evaluation( &mut self, - nested_goal_evaluation: &AddedGoalsEvaluation<'_>, + added_goals_evaluation: &AddedGoalsEvaluation<'_>, ) -> std::fmt::Result { - writeln!(self.f, "TRY_EVALUATE_ADDED_GOALS: {:?}", nested_goal_evaluation.result)?; + writeln!(self.f, "TRY_EVALUATE_ADDED_GOALS: {:?}", added_goals_evaluation.result)?; - for (n, revision) in nested_goal_evaluation.evaluations.iter().enumerate() { - writeln!(self.f, "REVISION {n}")?; + for (n, iterations) in added_goals_evaluation.evaluations.iter().enumerate() { + writeln!(self.f, "ITERATION {n}")?; self.nested(|this| { - for goal_evaluation in revision { - this.format_goal_evaluation(goal_evaluation)?; + for goal_evaluation in iterations { + this.format_nested_goal_evaluation(goal_evaluation)?; } Ok(()) })?; diff --git a/compiler/rustc_trait_selection/src/solve/alias_relate.rs b/compiler/rustc_trait_selection/src/solve/alias_relate.rs index 6b839d64b87ca..f7031c5f4933e 100644 --- a/compiler/rustc_trait_selection/src/solve/alias_relate.rs +++ b/compiler/rustc_trait_selection/src/solve/alias_relate.rs @@ -125,7 +125,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { direction: ty::AliasRelationDirection, invert: Invert, ) -> QueryResult<'tcx> { - self.probe_candidate("normalizes-to").enter(|ecx| { + self.probe_misc_candidate("normalizes-to").enter(|ecx| { ecx.normalizes_to_inner(param_env, alias, other, direction, invert)?; ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) }) @@ -175,7 +175,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { alias_rhs: ty::AliasTy<'tcx>, direction: ty::AliasRelationDirection, ) -> QueryResult<'tcx> { - self.probe_candidate("args relate").enter(|ecx| { + self.probe_misc_candidate("args relate").enter(|ecx| { match direction { ty::AliasRelationDirection::Equate => { ecx.eq(param_env, alias_lhs, alias_rhs)?; @@ -196,7 +196,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { rhs: ty::Term<'tcx>, direction: ty::AliasRelationDirection, ) -> QueryResult<'tcx> { - self.probe_candidate("bidir normalizes-to").enter(|ecx| { + self.probe_misc_candidate("bidir normalizes-to").enter(|ecx| { ecx.normalizes_to_inner( param_env, lhs.to_alias_ty(ecx.tcx()).unwrap(), diff --git a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs index 3750b3750bff1..45fd53c186ad4 100644 --- a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs +++ b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs @@ -5,8 +5,10 @@ use crate::traits::coherence; use rustc_hir::def_id::DefId; use rustc_infer::traits::query::NoSolution; use rustc_infer::traits::Reveal; -use rustc_middle::traits::solve::inspect::CandidateKind; -use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, QueryResult}; +use rustc_middle::traits::solve::inspect::ProbeKind; +use rustc_middle::traits::solve::{ + CandidateSource, CanonicalResponse, Certainty, Goal, QueryResult, +}; use rustc_middle::traits::BuiltinImplSource; use rustc_middle::ty::fast_reject::{SimplifiedType, TreatParams}; use rustc_middle::ty::{self, Ty, TyCtxt}; @@ -27,66 +29,6 @@ pub(super) struct Candidate<'tcx> { pub(super) result: CanonicalResponse<'tcx>, } -/// Possible ways the given goal can be proven. -#[derive(Debug, Clone, Copy)] -pub(super) enum CandidateSource { - /// A user written impl. - /// - /// ## Examples - /// - /// ```rust - /// fn main() { - /// let x: Vec = Vec::new(); - /// // This uses the impl from the standard library to prove `Vec: Clone`. - /// let y = x.clone(); - /// } - /// ``` - Impl(DefId), - /// A builtin impl generated by the compiler. When adding a new special - /// trait, try to use actual impls whenever possible. Builtin impls should - /// only be used in cases where the impl cannot be manually be written. - /// - /// Notable examples are auto traits, `Sized`, and `DiscriminantKind`. - /// For a list of all traits with builtin impls, check out the - /// [`EvalCtxt::assemble_builtin_impl_candidates`] method. Not - BuiltinImpl(BuiltinImplSource), - /// An assumption from the environment. - /// - /// More precisely we've used the `n-th` assumption in the `param_env`. - /// - /// ## Examples - /// - /// ```rust - /// fn is_clone(x: T) -> (T, T) { - /// // This uses the assumption `T: Clone` from the `where`-bounds - /// // to prove `T: Clone`. - /// (x.clone(), x) - /// } - /// ``` - ParamEnv(usize), - /// If the self type is an alias type, e.g. an opaque type or a projection, - /// we know the bounds on that alias to hold even without knowing its concrete - /// underlying type. - /// - /// More precisely this candidate is using the `n-th` bound in the `item_bounds` of - /// the self type. - /// - /// ## Examples - /// - /// ```rust - /// trait Trait { - /// type Assoc: Clone; - /// } - /// - /// fn foo(x: ::Assoc) { - /// // We prove `::Assoc` by looking at the bounds on `Assoc` in - /// // in the trait definition. - /// let _y = x.clone(); - /// } - /// ``` - AliasBound, -} - /// Methods used to assemble candidates for either trait or projection goals. pub(super) trait GoalKind<'tcx>: TypeFoldable> + Copy + Eq + std::fmt::Display @@ -393,7 +335,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { let tcx = self.tcx(); let &ty::Alias(_, projection_ty) = goal.predicate.self_ty().kind() else { return }; - candidates.extend(self.probe(|_| CandidateKind::NormalizedSelfTyAssembly).enter(|ecx| { + candidates.extend(self.probe(|_| ProbeKind::NormalizedSelfTyAssembly).enter(|ecx| { if num_steps < ecx.local_overflow_limit() { let normalized_ty = ecx.next_ty_infer(); let normalizes_to_goal = goal.with( @@ -882,7 +824,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { SolverMode::Coherence => {} }; - let result = self.probe_candidate("coherence unknowable").enter(|ecx| { + let result = self.probe_misc_candidate("coherence unknowable").enter(|ecx| { let trait_ref = goal.predicate.trait_ref(tcx); #[derive(Debug)] diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs index 5c2cbe399536a..7edc9764481aa 100644 --- a/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs +++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs @@ -12,8 +12,8 @@ use rustc_middle::infer::canonical::CanonicalVarInfos; use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind}; use rustc_middle::traits::solve::inspect; use rustc_middle::traits::solve::{ - CanonicalInput, CanonicalResponse, Certainty, IsNormalizesToHack, PredefinedOpaques, - PredefinedOpaquesData, QueryResult, + CanonicalInput, CanonicalResponse, Certainty, PredefinedOpaques, PredefinedOpaquesData, + QueryResult, }; use rustc_middle::traits::{specialization_graph, DefiningAnchor}; use rustc_middle::ty::{ @@ -28,8 +28,8 @@ use std::ops::ControlFlow; use crate::traits::vtable::{count_own_vtable_entries, prepare_vtable_segments, VtblSegment}; use super::inspect::ProofTreeBuilder; -use super::search_graph; use super::SolverMode; +use super::{search_graph, GoalEvaluationKind}; use super::{search_graph::SearchGraph, Goal}; pub use select::InferCtxtSelectExt; @@ -85,7 +85,7 @@ pub struct EvalCtxt<'a, 'tcx> { // evaluation code. tainted: Result<(), NoSolution>, - inspect: ProofTreeBuilder<'tcx>, + pub(super) inspect: ProofTreeBuilder<'tcx>, } #[derive(Debug, Clone)] @@ -149,7 +149,7 @@ pub trait InferCtxtEvalExt<'tcx> { generate_proof_tree: GenerateProofTree, ) -> ( Result<(bool, Certainty, Vec>>), NoSolution>, - Option>, + Option>, ); } @@ -161,10 +161,10 @@ impl<'tcx> InferCtxtEvalExt<'tcx> for InferCtxt<'tcx> { generate_proof_tree: GenerateProofTree, ) -> ( Result<(bool, Certainty, Vec>>), NoSolution>, - Option>, + Option>, ) { EvalCtxt::enter_root(self, generate_proof_tree, |ecx| { - ecx.evaluate_goal(IsNormalizesToHack::No, goal) + ecx.evaluate_goal(GoalEvaluationKind::Root, goal) }) } } @@ -185,7 +185,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { infcx: &InferCtxt<'tcx>, generate_proof_tree: GenerateProofTree, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> R, - ) -> (R, Option>) { + ) -> (R, Option>) { let mode = if infcx.intercrate { SolverMode::Coherence } else { SolverMode::Normal }; let mut search_graph = search_graph::SearchGraph::new(infcx.tcx, mode); @@ -237,7 +237,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { tcx: TyCtxt<'tcx>, search_graph: &'a mut search_graph::SearchGraph<'tcx>, canonical_input: CanonicalInput<'tcx>, - goal_evaluation: &mut ProofTreeBuilder<'tcx>, + canonical_goal_evaluation: &mut ProofTreeBuilder<'tcx>, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>, Goal<'tcx, ty::Predicate<'tcx>>) -> R, ) -> R { let intercrate = match search_graph.solver_mode() { @@ -260,7 +260,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { search_graph, nested_goals: NestedGoals::new(), tainted: Ok(()), - inspect: goal_evaluation.new_goal_evaluation_step(input), + inspect: canonical_goal_evaluation.new_goal_evaluation_step(), }; for &(key, ty) in &input.predefined_opaques_in_body.opaque_types { @@ -274,7 +274,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { let result = f(&mut ecx, input.goal); - goal_evaluation.goal_evaluation_step(ecx.inspect); + canonical_goal_evaluation.goal_evaluation_step(ecx.inspect); // When creating a query response we clone the opaque type constraints // instead of taking them. This would cause an ICE here, since we have @@ -302,24 +302,25 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { tcx: TyCtxt<'tcx>, search_graph: &'a mut search_graph::SearchGraph<'tcx>, canonical_input: CanonicalInput<'tcx>, - mut goal_evaluation: &mut ProofTreeBuilder<'tcx>, + goal_evaluation: &mut ProofTreeBuilder<'tcx>, ) -> QueryResult<'tcx> { - goal_evaluation.canonicalized_goal(canonical_input); + let mut canonical_goal_evaluation = + goal_evaluation.new_canonical_goal_evaluation(canonical_input); // Deal with overflow, caching, and coinduction. // // The actual solver logic happens in `ecx.compute_goal`. - ensure_sufficient_stack(|| { + let result = ensure_sufficient_stack(|| { search_graph.with_new_goal( tcx, canonical_input, - goal_evaluation, - |search_graph, goal_evaluation| { + &mut canonical_goal_evaluation, + |search_graph, canonical_goal_evaluation| { EvalCtxt::enter_canonical( tcx, search_graph, canonical_input, - goal_evaluation, + canonical_goal_evaluation, |ecx, goal| { let result = ecx.compute_goal(goal); ecx.inspect.query_result(result); @@ -328,18 +329,24 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { ) }, ) - }) + }); + + canonical_goal_evaluation.query_result(result); + goal_evaluation.canonical_goal_evaluation(canonical_goal_evaluation); + result } /// Recursively evaluates `goal`, returning whether any inference vars have /// been constrained and the certainty of the result. fn evaluate_goal( &mut self, - is_normalizes_to_hack: IsNormalizesToHack, + goal_evaluation_kind: GoalEvaluationKind, goal: Goal<'tcx, ty::Predicate<'tcx>>, ) -> Result<(bool, Certainty, Vec>>), NoSolution> { let (orig_values, canonical_goal) = self.canonicalize_goal(goal); - let mut goal_evaluation = self.inspect.new_goal_evaluation(goal, is_normalizes_to_hack); + + let mut goal_evaluation = + ProofTreeBuilder::new_goal_evaluation(self, goal, &orig_values, goal_evaluation_kind); let encountered_overflow = self.search_graph.encountered_overflow(); let canonical_response = EvalCtxt::evaluate_canonical_goal( self.tcx(), @@ -347,10 +354,9 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { canonical_goal, &mut goal_evaluation, ); - goal_evaluation.query_result(canonical_response); let canonical_response = match canonical_response { Err(e) => { - self.inspect.goal_evaluation(goal_evaluation); + ProofTreeBuilder::goal_evaluation(self, goal_evaluation, &[]); return Err(e); } Ok(response) => response, @@ -364,13 +370,12 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { canonical_response, ) { Err(e) => { - self.inspect.goal_evaluation(goal_evaluation); + ProofTreeBuilder::goal_evaluation(self, goal_evaluation, &[]); return Err(e); } Ok(response) => response, }; - goal_evaluation.returned_goals(&nested_goals); - self.inspect.goal_evaluation(goal_evaluation); + ProofTreeBuilder::goal_evaluation(self, goal_evaluation, &nested_goals); if !has_changed && !nested_goals.is_empty() { bug!("an unchanged goal shouldn't have any side-effects on instantiation"); @@ -385,7 +390,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { // solver cycle. if cfg!(debug_assertions) && has_changed - && is_normalizes_to_hack == IsNormalizesToHack::No + && goal_evaluation_kind != GoalEvaluationKind::NormalizesToHack && !self.search_graph.in_cycle() { // The nested evaluation has to happen with the original state @@ -558,7 +563,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { ); let (_, certainty, instantiate_goals) = - self.evaluate_goal(IsNormalizesToHack::Yes, unconstrained_goal)?; + self.evaluate_goal(GoalEvaluationKind::NormalizesToHack, unconstrained_goal)?; self.add_goals(instantiate_goals); // Finally, equate the goal's RHS with the unconstrained var. @@ -593,7 +598,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { for goal in goals.goals.drain(..) { let (has_changed, certainty, instantiate_goals) = - self.evaluate_goal(IsNormalizesToHack::No, goal)?; + self.evaluate_goal(GoalEvaluationKind::Nested, goal)?; self.add_goals(instantiate_goals); if has_changed { unchanged_certainty = None; @@ -916,7 +921,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { if candidate_key.def_id != key.def_id { continue; } - values.extend(self.probe_candidate("opaque type storage").enter(|ecx| { + values.extend(self.probe_misc_candidate("opaque type storage").enter(|ecx| { for (a, b) in std::iter::zip(candidate_key.args, key.args) { ecx.eq(param_env, a, b)?; } diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs index 0990b9bee90f6..1ddefd54e8e8f 100644 --- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs +++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs @@ -10,6 +10,7 @@ //! [c]: https://rustc-dev-guide.rust-lang.org/solve/canonicalization.html use super::{CanonicalInput, Certainty, EvalCtxt, Goal}; use crate::solve::canonicalize::{CanonicalizeMode, Canonicalizer}; +use crate::solve::inspect; use crate::solve::{response_no_constraints_raw, CanonicalResponse, QueryResult, Response}; use rustc_data_structures::fx::FxHashSet; use rustc_index::IndexVec; @@ -331,6 +332,22 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { } } +impl<'tcx> inspect::ProofTreeBuilder<'tcx> { + pub fn make_canonical_state>>( + ecx: &EvalCtxt<'_, 'tcx>, + data: T, + ) -> inspect::CanonicalState<'tcx, T> { + let state = inspect::State { var_values: ecx.var_values, data }; + let state = state.fold_with(&mut EagerResolver { infcx: ecx.infcx }); + Canonicalizer::canonicalize( + ecx.infcx, + CanonicalizeMode::Response { max_input_universe: ecx.max_input_universe }, + &mut vec![], + state, + ) + } +} + /// Resolves ty, region, and const vars to their inferred values or their root vars. struct EagerResolver<'a, 'tcx> { infcx: &'a InferCtxt<'tcx>, diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/probe.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/probe.rs index 317c43baf8f51..f88cfbac3f3eb 100644 --- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/probe.rs +++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/probe.rs @@ -1,5 +1,5 @@ use super::EvalCtxt; -use rustc_middle::traits::solve::{inspect, QueryResult}; +use rustc_middle::traits::solve::{inspect, CandidateSource, QueryResult}; use std::marker::PhantomData; pub(in crate::solve) struct ProbeCtxt<'me, 'a, 'tcx, F, T> { @@ -10,7 +10,7 @@ pub(in crate::solve) struct ProbeCtxt<'me, 'a, 'tcx, F, T> { impl<'tcx, F, T> ProbeCtxt<'_, '_, 'tcx, F, T> where - F: FnOnce(&T) -> inspect::CandidateKind<'tcx>, + F: FnOnce(&T) -> inspect::ProbeKind<'tcx>, { pub(in crate::solve) fn enter(self, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> T) -> T { let ProbeCtxt { ecx: outer_ecx, probe_kind, _result } = self; @@ -28,8 +28,8 @@ where }; let r = nested_ecx.infcx.probe(|_| f(&mut nested_ecx)); if !outer_ecx.inspect.is_noop() { - let cand_kind = probe_kind(&r); - nested_ecx.inspect.candidate_kind(cand_kind); + let probe_kind = probe_kind(&r); + nested_ecx.inspect.probe_kind(probe_kind); outer_ecx.inspect.goal_candidate(nested_ecx.inspect); } r @@ -41,25 +41,45 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> { /// as expensive as necessary to output the desired information. pub(in crate::solve) fn probe(&mut self, probe_kind: F) -> ProbeCtxt<'_, 'a, 'tcx, F, T> where - F: FnOnce(&T) -> inspect::CandidateKind<'tcx>, + F: FnOnce(&T) -> inspect::ProbeKind<'tcx>, { ProbeCtxt { ecx: self, probe_kind, _result: PhantomData } } - pub(in crate::solve) fn probe_candidate( + pub(in crate::solve) fn probe_misc_candidate( &mut self, name: &'static str, ) -> ProbeCtxt< '_, 'a, 'tcx, - impl FnOnce(&QueryResult<'tcx>) -> inspect::CandidateKind<'tcx>, + impl FnOnce(&QueryResult<'tcx>) -> inspect::ProbeKind<'tcx>, QueryResult<'tcx>, > { ProbeCtxt { ecx: self, - probe_kind: move |result: &QueryResult<'tcx>| inspect::CandidateKind::Candidate { - name: name.to_string(), + probe_kind: move |result: &QueryResult<'tcx>| inspect::ProbeKind::MiscCandidate { + name, + result: *result, + }, + _result: PhantomData, + } + } + + pub(in crate::solve) fn probe_trait_candidate( + &mut self, + source: CandidateSource, + ) -> ProbeCtxt< + '_, + 'a, + 'tcx, + impl FnOnce(&QueryResult<'tcx>) -> inspect::ProbeKind<'tcx>, + QueryResult<'tcx>, + > { + ProbeCtxt { + ecx: self, + probe_kind: move |result: &QueryResult<'tcx>| inspect::ProbeKind::TraitCandidate { + source, result: *result, }, _result: PhantomData, diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/select.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/select.rs index ca4a4c9510c04..6a18f2eac9dc3 100644 --- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/select.rs +++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/select.rs @@ -4,14 +4,14 @@ use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt}; use rustc_infer::traits::{ Obligation, PolyTraitObligation, PredicateObligation, Selection, SelectionResult, TraitEngine, }; -use rustc_middle::traits::solve::{CanonicalInput, Certainty, Goal}; +use rustc_middle::traits::solve::{CandidateSource, CanonicalInput, Certainty, Goal}; use rustc_middle::traits::{ BuiltinImplSource, ImplSource, ImplSourceUserDefinedData, ObligationCause, SelectionError, }; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::DUMMY_SP; -use crate::solve::assembly::{Candidate, CandidateSource}; +use crate::solve::assembly::Candidate; use crate::solve::eval_ctxt::{EvalCtxt, GenerateProofTree}; use crate::solve::inspect::ProofTreeBuilder; use crate::traits::StructurallyNormalizeExt; diff --git a/compiler/rustc_trait_selection/src/solve/inspect.rs b/compiler/rustc_trait_selection/src/solve/inspect.rs index cda68396321ce..49ffb5aa5e2d3 100644 --- a/compiler/rustc_trait_selection/src/solve/inspect.rs +++ b/compiler/rustc_trait_selection/src/solve/inspect.rs @@ -1,87 +1,114 @@ use rustc_middle::traits::query::NoSolution; -use rustc_middle::traits::solve::inspect::{self, CacheHit, CandidateKind}; -use rustc_middle::traits::solve::{ - CanonicalInput, Certainty, Goal, IsNormalizesToHack, QueryInput, QueryResult, -}; +use rustc_middle::traits::solve::{CanonicalInput, Certainty, Goal, QueryResult}; use rustc_middle::ty::{self, TyCtxt}; use rustc_session::config::DumpSolverProofTree; use super::eval_ctxt::UseGlobalCache; -use super::GenerateProofTree; +use super::{EvalCtxt, GenerateProofTree, GoalEvaluationKind}; -#[derive(Eq, PartialEq, Debug, Hash, HashStable)] -pub struct WipGoalEvaluation<'tcx> { - pub uncanonicalized_goal: Goal<'tcx, ty::Predicate<'tcx>>, - pub canonicalized_goal: Option>, +pub use rustc_middle::traits::solve::inspect::*; - pub evaluation_steps: Vec>, +pub(super) mod analyse; - pub cache_hit: Option, +#[derive(Debug)] +pub struct WipRootGoalEvaluation<'tcx> { + goal: Goal<'tcx, ty::Predicate<'tcx>>, + orig_values: Vec>, + evaluation: Option>, + returned_goals: Vec>>, +} + +impl<'tcx> WipRootGoalEvaluation<'tcx> { + pub(super) fn finalize(self) -> RootGoalEvaluation<'tcx> { + RootGoalEvaluation { + goal: self.goal, + orig_values: self.orig_values, + evaluation: self.evaluation.unwrap().finalize(), + returned_goals: self.returned_goals, + } + } +} + +#[derive(Debug)] +pub struct WipNestedGoalEvaluation<'tcx> { + pub goal: CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>, + pub orig_values: CanonicalState<'tcx, Vec>>, + pub evaluation: Option>, pub is_normalizes_to_hack: IsNormalizesToHack, - pub returned_goals: Vec>>, + pub returned_goals: Vec>>>, +} + +impl<'tcx> WipNestedGoalEvaluation<'tcx> { + pub(super) fn finalize(self) -> NestedGoalEvaluation<'tcx> { + NestedGoalEvaluation { + goal: self.goal, + orig_values: self.orig_values, + evaluation: self.evaluation.unwrap().finalize(), + is_normalizes_to_hack: self.is_normalizes_to_hack, + returned_goals: self.returned_goals, + } + } +} +#[derive(Debug)] +pub struct WipCanonicalGoalEvaluation<'tcx> { + pub goal: CanonicalInput<'tcx>, + pub cache_hit: Option, + pub evaluation_steps: Vec>, pub result: Option>, } -impl<'tcx> WipGoalEvaluation<'tcx> { - pub fn finalize(self) -> inspect::GoalEvaluation<'tcx> { - inspect::GoalEvaluation { - uncanonicalized_goal: self.uncanonicalized_goal, - canonicalized_goal: self.canonicalized_goal.unwrap(), - kind: match self.cache_hit { - Some(hit) => inspect::GoalEvaluationKind::CacheHit(hit), - None => inspect::GoalEvaluationKind::Uncached { +impl<'tcx> WipCanonicalGoalEvaluation<'tcx> { + pub(super) fn finalize(self) -> CanonicalGoalEvaluation<'tcx> { + let data = match self.cache_hit { + Some(hit) => GoalEvaluationData::CacheHit(hit), + None => { + assert!(!self.evaluation_steps.is_empty()); + GoalEvaluationData::Uncached { revisions: self .evaluation_steps .into_iter() .map(WipGoalEvaluationStep::finalize) .collect(), - }, - }, - is_normalizes_to_hack: self.is_normalizes_to_hack, - returned_goals: self.returned_goals, - result: self.result.unwrap(), - } + } + } + }; + + CanonicalGoalEvaluation { goal: self.goal, data, result: self.result.unwrap() } } } -#[derive(Eq, PartialEq, Debug, Hash, HashStable)] +#[derive(Debug)] pub struct WipAddedGoalsEvaluation<'tcx> { - pub evaluations: Vec>>, + pub evaluations: Vec>>, pub result: Option>, } impl<'tcx> WipAddedGoalsEvaluation<'tcx> { - pub fn finalize(self) -> inspect::AddedGoalsEvaluation<'tcx> { - inspect::AddedGoalsEvaluation { + pub(super) fn finalize(self) -> AddedGoalsEvaluation<'tcx> { + AddedGoalsEvaluation { evaluations: self .evaluations .into_iter() - .map(|evaluations| { - evaluations.into_iter().map(WipGoalEvaluation::finalize).collect() - }) + .map(|evaluations| evaluations.into_iter().map(|e| e.finalize()).collect()) .collect(), result: self.result.unwrap(), } } } -#[derive(Eq, PartialEq, Debug, Hash, HashStable)] +#[derive(Debug)] pub struct WipGoalEvaluationStep<'tcx> { - pub instantiated_goal: QueryInput<'tcx, ty::Predicate<'tcx>>, - - pub nested_goal_evaluations: Vec>, + pub added_goals_evaluations: Vec>, pub candidates: Vec>, - pub result: Option>, } impl<'tcx> WipGoalEvaluationStep<'tcx> { - pub fn finalize(self) -> inspect::GoalEvaluationStep<'tcx> { - inspect::GoalEvaluationStep { - instantiated_goal: self.instantiated_goal, - nested_goal_evaluations: self - .nested_goal_evaluations + pub(super) fn finalize(self) -> GoalEvaluationStep<'tcx> { + GoalEvaluationStep { + added_goals_evaluations: self + .added_goals_evaluations .into_iter() .map(WipAddedGoalsEvaluation::finalize) .collect(), @@ -91,18 +118,18 @@ impl<'tcx> WipGoalEvaluationStep<'tcx> { } } -#[derive(Eq, PartialEq, Debug, Hash, HashStable)] +#[derive(Debug)] pub struct WipGoalCandidate<'tcx> { - pub nested_goal_evaluations: Vec>, + pub added_goals_evaluations: Vec>, pub candidates: Vec>, - pub kind: Option>, + pub kind: Option>, } impl<'tcx> WipGoalCandidate<'tcx> { - pub fn finalize(self) -> inspect::GoalCandidate<'tcx> { - inspect::GoalCandidate { - nested_goal_evaluations: self - .nested_goal_evaluations + pub(super) fn finalize(self) -> GoalCandidate<'tcx> { + GoalCandidate { + added_goals_evaluations: self + .added_goals_evaluations .into_iter() .map(WipAddedGoalsEvaluation::finalize) .collect(), @@ -115,15 +142,29 @@ impl<'tcx> WipGoalCandidate<'tcx> { #[derive(Debug)] pub enum DebugSolver<'tcx> { Root, - GoalEvaluation(WipGoalEvaluation<'tcx>), + RootGoalEvaluation(WipRootGoalEvaluation<'tcx>), + NestedGoalEvaluation(WipNestedGoalEvaluation<'tcx>), + CanonicalGoalEvaluation(WipCanonicalGoalEvaluation<'tcx>), AddedGoalsEvaluation(WipAddedGoalsEvaluation<'tcx>), GoalEvaluationStep(WipGoalEvaluationStep<'tcx>), GoalCandidate(WipGoalCandidate<'tcx>), } -impl<'tcx> From> for DebugSolver<'tcx> { - fn from(g: WipGoalEvaluation<'tcx>) -> DebugSolver<'tcx> { - DebugSolver::GoalEvaluation(g) +impl<'tcx> From> for DebugSolver<'tcx> { + fn from(g: WipRootGoalEvaluation<'tcx>) -> DebugSolver<'tcx> { + DebugSolver::RootGoalEvaluation(g) + } +} + +impl<'tcx> From> for DebugSolver<'tcx> { + fn from(g: WipNestedGoalEvaluation<'tcx>) -> DebugSolver<'tcx> { + DebugSolver::NestedGoalEvaluation(g) + } +} + +impl<'tcx> From> for DebugSolver<'tcx> { + fn from(g: WipCanonicalGoalEvaluation<'tcx>) -> DebugSolver<'tcx> { + DebugSolver::CanonicalGoalEvaluation(g) } } @@ -164,11 +205,11 @@ impl<'tcx> ProofTreeBuilder<'tcx> { } } - fn nested(&self, state: impl Into>) -> Self { + fn nested>>(&self, state: impl FnOnce() -> T) -> Self { match &self.state { Some(prev_state) => Self { state: Some(Box::new(BuilderData { - tree: state.into(), + tree: state().into(), use_global_cache: prev_state.use_global_cache, })), }, @@ -180,23 +221,23 @@ impl<'tcx> ProofTreeBuilder<'tcx> { self.state.as_mut().map(|boxed| &mut boxed.tree) } - pub fn finalize(self) -> Option> { + pub(super) fn finalize(self) -> Option> { match self.state?.tree { - DebugSolver::GoalEvaluation(wip_goal_evaluation) => { - Some(wip_goal_evaluation.finalize()) + DebugSolver::RootGoalEvaluation(root_goal_evaluation) => { + Some(root_goal_evaluation.finalize()) } root => unreachable!("unexpected proof tree builder root node: {:?}", root), } } - pub fn use_global_cache(&self) -> bool { + pub(super) fn use_global_cache(&self) -> bool { self.state .as_ref() .map(|state| matches!(state.use_global_cache, UseGlobalCache::Yes)) .unwrap_or(true) } - pub fn new_maybe_root( + pub(super) fn new_maybe_root( tcx: TyCtxt<'tcx>, generate_proof_tree: GenerateProofTree, ) -> ProofTreeBuilder<'tcx> { @@ -220,136 +261,172 @@ impl<'tcx> ProofTreeBuilder<'tcx> { } } - pub fn new_root(use_global_cache: UseGlobalCache) -> ProofTreeBuilder<'tcx> { + pub(super) fn new_root(use_global_cache: UseGlobalCache) -> ProofTreeBuilder<'tcx> { ProofTreeBuilder::new(DebugSolver::Root, use_global_cache) } - pub fn new_noop() -> ProofTreeBuilder<'tcx> { + pub(super) fn new_noop() -> ProofTreeBuilder<'tcx> { ProofTreeBuilder { state: None } } - pub fn is_noop(&self) -> bool { + pub(super) fn is_noop(&self) -> bool { self.state.is_none() } - pub fn new_goal_evaluation( - &mut self, + pub(super) fn new_goal_evaluation( + ecx: &EvalCtxt<'_, 'tcx>, goal: Goal<'tcx, ty::Predicate<'tcx>>, - is_normalizes_to_hack: IsNormalizesToHack, + orig_values: &[ty::GenericArg<'tcx>], + goal_evaluation_kind: GoalEvaluationKind, ) -> ProofTreeBuilder<'tcx> { - if self.state.is_none() { - return ProofTreeBuilder { state: None }; - } - - self.nested(WipGoalEvaluation { - uncanonicalized_goal: goal, - canonicalized_goal: None, - evaluation_steps: vec![], + let is_normalizes_to_hack = match goal_evaluation_kind { + GoalEvaluationKind::Root => { + return ecx.inspect.nested(|| WipRootGoalEvaluation { + goal, + orig_values: orig_values.to_vec(), + evaluation: None, + returned_goals: vec![], + }); + } + GoalEvaluationKind::NormalizesToHack => IsNormalizesToHack::Yes, + GoalEvaluationKind::Nested => IsNormalizesToHack::No, + }; + + ecx.inspect.nested(|| WipNestedGoalEvaluation { + goal: Self::make_canonical_state(ecx, goal), + orig_values: Self::make_canonical_state(ecx, orig_values.to_vec()), + evaluation: None, is_normalizes_to_hack, - cache_hit: None, returned_goals: vec![], + }) + } + + pub(super) fn new_canonical_goal_evaluation( + &mut self, + goal: CanonicalInput<'tcx>, + ) -> ProofTreeBuilder<'tcx> { + self.nested(|| WipCanonicalGoalEvaluation { + goal, + cache_hit: None, + evaluation_steps: vec![], result: None, }) } - pub fn canonicalized_goal(&mut self, canonical_goal: CanonicalInput<'tcx>) { + pub(super) fn canonical_goal_evaluation( + &mut self, + canonical_goal_evaluation: ProofTreeBuilder<'tcx>, + ) { if let Some(this) = self.as_mut() { - match this { - DebugSolver::GoalEvaluation(goal_evaluation) => { - assert_eq!(goal_evaluation.canonicalized_goal.replace(canonical_goal), None); - } + match (this, canonical_goal_evaluation.state.unwrap().tree) { + ( + DebugSolver::RootGoalEvaluation(WipRootGoalEvaluation { evaluation, .. }) + | DebugSolver::NestedGoalEvaluation(WipNestedGoalEvaluation { + evaluation, .. + }), + DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation), + ) => *evaluation = Some(canonical_goal_evaluation), _ => unreachable!(), } } } - pub fn cache_hit(&mut self, cache_hit: CacheHit) { + pub(super) fn cache_hit(&mut self, cache_hit: CacheHit) { if let Some(this) = self.as_mut() { match this { - DebugSolver::GoalEvaluation(goal_evaluation) => { - assert_eq!(goal_evaluation.cache_hit.replace(cache_hit), None); + DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => { + assert_eq!(canonical_goal_evaluation.cache_hit.replace(cache_hit), None); } _ => unreachable!(), }; } } - pub fn returned_goals(&mut self, goals: &[Goal<'tcx, ty::Predicate<'tcx>>]) { - if let Some(this) = self.as_mut() { - match this { - DebugSolver::GoalEvaluation(evaluation) => { - assert!(evaluation.returned_goals.is_empty()); - evaluation.returned_goals.extend(goals); + pub(super) fn goal_evaluation( + ecx: &mut EvalCtxt<'_, 'tcx>, + goal_evaluation: ProofTreeBuilder<'tcx>, + goals: &[Goal<'tcx, ty::Predicate<'tcx>>], + ) { + // Can't use `if let Some(this) = ecx.inspect.as_mut()` here because + // we have to immutably use the `EvalCtxt` for `make_canonical_state`. + if ecx.inspect.is_noop() { + return; + } + + match goal_evaluation.state.unwrap().tree { + DebugSolver::NestedGoalEvaluation(mut nested_goal_evaluation) => { + assert!(nested_goal_evaluation.returned_goals.is_empty()); + for &goal in goals { + let goal = Self::make_canonical_state(ecx, goal); + nested_goal_evaluation.returned_goals.push(goal); + } + + if let DebugSolver::AddedGoalsEvaluation(added_goals_evaluation) = + ecx.inspect.as_mut().unwrap() + { + added_goals_evaluation + .evaluations + .last_mut() + .unwrap() + .push(nested_goal_evaluation); + } else { + unreachable!() } - _ => unreachable!(), } - } - } - pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<'tcx>) { - if let Some(this) = self.as_mut() { - match (this, goal_evaluation.state.unwrap().tree) { - ( - DebugSolver::AddedGoalsEvaluation(WipAddedGoalsEvaluation { - evaluations, .. - }), - DebugSolver::GoalEvaluation(goal_evaluation), - ) => evaluations.last_mut().unwrap().push(goal_evaluation), - (this @ DebugSolver::Root, goal_evaluation) => *this = goal_evaluation, - _ => unreachable!(), + DebugSolver::RootGoalEvaluation(mut root_goal_evaluation) => { + assert!(root_goal_evaluation.returned_goals.is_empty()); + root_goal_evaluation.returned_goals.extend(goals); + + let this = ecx.inspect.as_mut().unwrap(); + assert!(matches!(this, DebugSolver::Root)); + *this = DebugSolver::RootGoalEvaluation(root_goal_evaluation); } - } - } - pub fn new_goal_evaluation_step( - &mut self, - instantiated_goal: QueryInput<'tcx, ty::Predicate<'tcx>>, - ) -> ProofTreeBuilder<'tcx> { - if self.state.is_none() { - return ProofTreeBuilder { state: None }; + _ => unreachable!(), } + } - self.nested(WipGoalEvaluationStep { - instantiated_goal, - nested_goal_evaluations: vec![], + pub(super) fn new_goal_evaluation_step(&mut self) -> ProofTreeBuilder<'tcx> { + self.nested(|| WipGoalEvaluationStep { + added_goals_evaluations: vec![], candidates: vec![], result: None, }) } - pub fn goal_evaluation_step(&mut self, goal_eval_step: ProofTreeBuilder<'tcx>) { + pub(super) fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder<'tcx>) { if let Some(this) = self.as_mut() { - match (this, goal_eval_step.state.unwrap().tree) { - (DebugSolver::GoalEvaluation(goal_eval), DebugSolver::GoalEvaluationStep(step)) => { - goal_eval.evaluation_steps.push(step); + match (this, goal_evaluation_step.state.unwrap().tree) { + ( + DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluations), + DebugSolver::GoalEvaluationStep(goal_evaluation_step), + ) => { + canonical_goal_evaluations.evaluation_steps.push(goal_evaluation_step); } _ => unreachable!(), } } } - pub fn new_goal_candidate(&mut self) -> ProofTreeBuilder<'tcx> { - if self.state.is_none() { - return ProofTreeBuilder { state: None }; - } - - self.nested(WipGoalCandidate { - nested_goal_evaluations: vec![], + pub(super) fn new_goal_candidate(&mut self) -> ProofTreeBuilder<'tcx> { + self.nested(|| WipGoalCandidate { + added_goals_evaluations: vec![], candidates: vec![], kind: None, }) } - pub fn candidate_kind(&mut self, candidate_kind: CandidateKind<'tcx>) { + pub(super) fn probe_kind(&mut self, probe_kind: ProbeKind<'tcx>) { if let Some(this) = self.as_mut() { match this { DebugSolver::GoalCandidate(this) => { - assert_eq!(this.kind.replace(candidate_kind), None) + assert_eq!(this.kind.replace(probe_kind), None) } _ => unreachable!(), } } } - pub fn goal_candidate(&mut self, candidate: ProofTreeBuilder<'tcx>) { + pub(super) fn goal_candidate(&mut self, candidate: ProofTreeBuilder<'tcx>) { if let Some(this) = self.as_mut() { match (this, candidate.state.unwrap().tree) { ( @@ -362,15 +439,11 @@ impl<'tcx> ProofTreeBuilder<'tcx> { } } - pub fn new_evaluate_added_goals(&mut self) -> ProofTreeBuilder<'tcx> { - if self.state.is_none() { - return ProofTreeBuilder { state: None }; - } - - self.nested(WipAddedGoalsEvaluation { evaluations: vec![], result: None }) + pub(super) fn new_evaluate_added_goals(&mut self) -> ProofTreeBuilder<'tcx> { + self.nested(|| WipAddedGoalsEvaluation { evaluations: vec![], result: None }) } - pub fn evaluate_added_goals_loop_start(&mut self) { + pub(super) fn evaluate_added_goals_loop_start(&mut self) { if let Some(this) = self.as_mut() { match this { DebugSolver::AddedGoalsEvaluation(this) => { @@ -381,7 +454,7 @@ impl<'tcx> ProofTreeBuilder<'tcx> { } } - pub fn eval_added_goals_result(&mut self, result: Result) { + pub(super) fn eval_added_goals_result(&mut self, result: Result) { if let Some(this) = self.as_mut() { match this { DebugSolver::AddedGoalsEvaluation(this) => { @@ -392,36 +465,37 @@ impl<'tcx> ProofTreeBuilder<'tcx> { } } - pub fn added_goals_evaluation(&mut self, goals_evaluation: ProofTreeBuilder<'tcx>) { + pub(super) fn added_goals_evaluation( + &mut self, + added_goals_evaluation: ProofTreeBuilder<'tcx>, + ) { if let Some(this) = self.as_mut() { - match (this, goals_evaluation.state.unwrap().tree) { + match (this, added_goals_evaluation.state.unwrap().tree) { ( DebugSolver::GoalEvaluationStep(WipGoalEvaluationStep { - nested_goal_evaluations, + added_goals_evaluations, .. }) | DebugSolver::GoalCandidate(WipGoalCandidate { - nested_goal_evaluations, .. + added_goals_evaluations, .. }), DebugSolver::AddedGoalsEvaluation(added_goals_evaluation), - ) => nested_goal_evaluations.push(added_goals_evaluation), + ) => added_goals_evaluations.push(added_goals_evaluation), _ => unreachable!(), } } } - pub fn query_result(&mut self, result: QueryResult<'tcx>) { + pub(super) fn query_result(&mut self, result: QueryResult<'tcx>) { if let Some(this) = self.as_mut() { match this { - DebugSolver::GoalEvaluation(goal_evaluation) => { - assert_eq!(goal_evaluation.result.replace(result), None); + DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => { + assert_eq!(canonical_goal_evaluation.result.replace(result), None); } DebugSolver::GoalEvaluationStep(evaluation_step) => { assert_eq!(evaluation_step.result.replace(result), None); } - DebugSolver::Root - | DebugSolver::AddedGoalsEvaluation(_) - | DebugSolver::GoalCandidate(_) => unreachable!(), + _ => unreachable!(), } } } diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs new file mode 100644 index 0000000000000..7949a9f3ec78d --- /dev/null +++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs @@ -0,0 +1,236 @@ +use std::ops::ControlFlow; + +use rustc_data_structures::fx::FxIndexSet; +use rustc_infer::traits::TraitEngine; +use rustc_infer::{infer::InferCtxt, traits::PredicateObligation}; +use rustc_middle::traits::query::NoSolution; +use rustc_middle::traits::solve::inspect::{self, RootGoalEvaluation}; +use rustc_middle::traits::solve::{Certainty, Goal}; +use rustc_middle::traits::ObligationCause; +use rustc_middle::ty; +use rustc_middle::ty::print::with_no_trimmed_paths; +use rustc_middle::ty::TypeVisitableExt; + +use crate::solve::{GenerateProofTree, InferCtxtEvalExt, UseGlobalCache}; +use crate::traits::coherence::{self, Conflict}; +use crate::traits::TraitEngineExt; +use crate::traits::{IntercrateAmbiguityCause, StructurallyNormalizeExt}; + +pub struct InspectGoal<'a, 'tcx> { + infcx: &'a InferCtxt<'tcx>, + goal: Goal<'tcx, ty::Predicate<'tcx>>, +} + +pub struct InspectCandidate<'a, 'tcx> { + infcx: &'a InferCtxt<'tcx>, +} + +impl<'a, 'tcx> InspectCandidate<'a, 'tcx> { + pub fn infcx(&self) -> &'a InferCtxt<'tcx> { + self.infcx + } + + /// `None` in case this is the only candidate to prove the `goal`. + pub fn kind(&self) -> Option> { + todo!() + } + + pub fn result(&self) -> Result { + todo!() + } + + pub fn visit_nested>( + &self, + visitor: &mut V, + ) -> ControlFlow { + // TODO + todo!() + } +} + +impl<'a, 'tcx> InspectGoal<'a, 'tcx> { + pub fn infcx(&self) -> &'a InferCtxt<'tcx> { + self.infcx + } + + pub fn goal(&self) -> Goal<'tcx, ty::Predicate<'tcx>> { + self.goal + } + + pub fn result(&self) -> Result { + // TODO + todo!() + } + + pub fn candidates(&self) -> Vec> { + // TODO + todo!() + } + + fn new(infcx: &'a InferCtxt<'tcx>, root: &'a RootGoalEvaluation<'tcx>) -> Self { + InspectGoal { infcx, goal: root.goal } + } +} + +/// The public API to interact with proof trees. +pub trait ProofTreeVisitor<'tcx> { + type BreakTy; + + fn visit_goal(&mut self, goal: &InspectGoal<'_, 'tcx>) -> ControlFlow; +} + +pub trait ProofTreeInferCtxtExt<'tcx> { + fn visit_proof_tree>( + &self, + root: &RootGoalEvaluation<'tcx>, + visitor: &mut V, + ) -> ControlFlow; +} + +impl<'tcx> ProofTreeInferCtxtExt<'tcx> for InferCtxt<'tcx> { + fn visit_proof_tree>( + &self, + root: &RootGoalEvaluation<'tcx>, + visitor: &mut V, + ) -> ControlFlow { + visitor.visit_goal(&InspectGoal::new(self, root)) + } +} + +pub(crate) fn compute_intercrate_ambiguity_causes<'tcx>( + infcx: &InferCtxt<'tcx>, + obligations: &[PredicateObligation<'tcx>], +) -> FxIndexSet { + let mut causes: FxIndexSet = Default::default(); + + for obligation in obligations { + infcx.probe(|_| { + let (_, proof_tree) = infcx.evaluate_root_goal( + obligation.clone().into(), + GenerateProofTree::Yes(UseGlobalCache::No), + ); + let proof_tree = proof_tree.unwrap(); + search_ambiguity_causes(infcx, proof_tree, &mut causes); + }) + } + + causes +} + +struct AmbiguityCausesVisitor<'a> { + causes: &'a mut FxIndexSet, +} + +impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a> { + type BreakTy = !; + fn visit_goal(&mut self, goal: &InspectGoal<'_, 'tcx>) -> ControlFlow { + let infcx = goal.infcx(); + for cand in goal.candidates() { + cand.visit_nested(self)?; + } + // When searching for intercrate ambiguity causes, we only need to look + // at ambiguous goals, as for others the coherence unknowable candidate + // was irrelevant. + match goal.result() { + Ok(Certainty::Maybe(_)) => {} + Ok(Certainty::Yes) | Err(NoSolution) => return ControlFlow::Continue(()), + } + + let Goal { param_env, predicate } = goal.goal(); + + let trait_ref = match predicate.kind().no_bound_vars() { + Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(tr))) => tr.trait_ref, + Some(ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj))) => { + proj.projection_ty.trait_ref(infcx.tcx) + } + _ => return ControlFlow::Continue(()), + }; + + let mut ambiguity_cause = None; + for cand in goal.candidates() { + match goal.result() { + Ok(Certainty::Maybe(_)) => {} + // We only add intercrate ambiguity causes if the goal would + // otherwise result in an error. + // + // FIXME: this isn't quite right. Changing a goal from YES with + // inference contraints to AMBIGUOUS can also cause a goal to not + // fail. + Ok(Certainty::Yes) => { + ambiguity_cause = None; + break; + } + Err(NoSolution) => continue, + } + + // FIXME: boiiii, using string comparisions here sure is scuffed. + if let Some(inspect::ProbeKind::MiscCandidate { + name: "coherence unknowable", + result: _, + }) = cand.kind() + { + let lazily_normalize_ty = |ty| { + let mut fulfill_cx = >::new(infcx); + match infcx + .at(&ObligationCause::dummy(), param_env) + .structurally_normalize(ty, &mut *fulfill_cx) + { + Ok(ty) => Ok(ty), + Err(_errs) => Err(()), + } + }; + + infcx.probe(|_| { + match coherence::trait_ref_is_knowable( + infcx.tcx, + trait_ref, + lazily_normalize_ty, + ) { + Err(()) => {} + Ok(Ok(())) => warn!("expected an unknowable trait ref: {trait_ref:?}"), + Ok(Err(conflict)) => { + if !trait_ref.references_error() { + let self_ty = trait_ref.self_ty(); + let (trait_desc, self_desc) = with_no_trimmed_paths!({ + let trait_desc = trait_ref.print_only_trait_path().to_string(); + let self_desc = self_ty + .has_concrete_skeleton() + .then(|| self_ty.to_string()); + (trait_desc, self_desc) + }); + ambiguity_cause = Some(match conflict { + Conflict::Upstream => { + IntercrateAmbiguityCause::UpstreamCrateUpdate { + trait_desc, + self_desc, + } + } + Conflict::Downstream => { + IntercrateAmbiguityCause::DownstreamCrate { + trait_desc, + self_desc, + } + } + }); + } + } + } + }) + } + } + + if let Some(ambiguity_cause) = ambiguity_cause { + self.causes.insert(ambiguity_cause); + } + + ControlFlow::Continue(()) + } +} + +fn search_ambiguity_causes<'tcx>( + infcx: &InferCtxt<'tcx>, + proof_tree: inspect::RootGoalEvaluation<'tcx>, + causes: &mut FxIndexSet, +) { + infcx.visit_proof_tree(&proof_tree, &mut AmbiguityCausesVisitor { causes }); +} diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs index 75a99f799a24c..e6ba1f7b9a88b 100644 --- a/compiler/rustc_trait_selection/src/solve/mod.rs +++ b/compiler/rustc_trait_selection/src/solve/mod.rs @@ -44,6 +44,8 @@ pub use eval_ctxt::{ EvalCtxt, GenerateProofTree, InferCtxtEvalExt, InferCtxtSelectExt, UseGlobalCache, }; pub use fulfill::FulfillmentCtxt; +pub(crate) use inspect::analyse::compute_intercrate_ambiguity_causes; +pub use inspect::analyse::{InspectCandidate, InspectGoal, ProofTreeInferCtxtExt}; pub(crate) use normalize::{deeply_normalize, deeply_normalize_with_skipped_universes}; #[derive(Debug, Clone, Copy)] @@ -59,6 +61,13 @@ enum SolverMode { Coherence, } +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +enum GoalEvaluationKind { + Root, + NormalizesToHack, + Nested, +} + trait CanonicalResponseExt { fn has_no_inference_or_external_constraints(&self) -> bool; diff --git a/compiler/rustc_trait_selection/src/solve/project_goals.rs b/compiler/rustc_trait_selection/src/solve/project_goals.rs index e1980f4d7bb0e..b389b26f2c51e 100644 --- a/compiler/rustc_trait_selection/src/solve/project_goals.rs +++ b/compiler/rustc_trait_selection/src/solve/project_goals.rs @@ -8,8 +8,9 @@ use rustc_hir::LangItem; use rustc_infer::traits::query::NoSolution; use rustc_infer::traits::specialization_graph::LeafDef; use rustc_infer::traits::Reveal; -use rustc_middle::traits::solve::inspect::CandidateKind; -use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, QueryResult}; +use rustc_middle::traits::solve::{ + CandidateSource, CanonicalResponse, Certainty, Goal, QueryResult, +}; use rustc_middle::traits::BuiltinImplSource; use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams}; use rustc_middle::ty::ProjectionPredicate; @@ -113,7 +114,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> { if let Some(projection_pred) = assumption.as_projection_clause() { if projection_pred.projection_def_id() == goal.predicate.def_id() { let tcx = ecx.tcx(); - ecx.probe_candidate("assumption").enter(|ecx| { + ecx.probe_misc_candidate("assumption").enter(|ecx| { let assumption_projection_pred = ecx.instantiate_binder_with_infer(projection_pred); ecx.eq( @@ -155,7 +156,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> { return Err(NoSolution); } - ecx.probe(|r| CandidateKind::Candidate { name: "impl".into(), result: *r }).enter(|ecx| { + ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| { let impl_args = ecx.fresh_args_for_item(impl_def_id); let impl_trait_ref = impl_trait_ref.instantiate(tcx, impl_args); @@ -347,7 +348,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> { goal: Goal<'tcx, Self>, ) -> QueryResult<'tcx> { let tcx = ecx.tcx(); - ecx.probe_candidate("builtin pointee").enter(|ecx| { + ecx.probe_misc_candidate("builtin pointee").enter(|ecx| { let metadata_ty = match goal.predicate.self_ty().kind() { ty::Bool | ty::Char @@ -549,7 +550,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> { ), }; - ecx.probe_candidate("builtin discriminant kind").enter(|ecx| { + ecx.probe_misc_candidate("builtin discriminant kind").enter(|ecx| { ecx.eq(goal.param_env, goal.predicate.term, discriminant_ty.into()) .expect("expected goal term to be fully unconstrained"); ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) diff --git a/compiler/rustc_trait_selection/src/solve/search_graph/mod.rs b/compiler/rustc_trait_selection/src/solve/search_graph/mod.rs index 49ebfa4e6cbce..40cf0b5c10d56 100644 --- a/compiler/rustc_trait_selection/src/solve/search_graph/mod.rs +++ b/compiler/rustc_trait_selection/src/solve/search_graph/mod.rs @@ -200,6 +200,7 @@ impl<'tcx> SearchGraph<'tcx> { available_depth, ) { + inspect.cache_hit(CacheHit::Global); self.on_cache_hit(reached_depth, encountered_overflow); return result; } diff --git a/compiler/rustc_trait_selection/src/solve/trait_goals.rs b/compiler/rustc_trait_selection/src/solve/trait_goals.rs index ee6f1686b8238..aa23d568fade7 100644 --- a/compiler/rustc_trait_selection/src/solve/trait_goals.rs +++ b/compiler/rustc_trait_selection/src/solve/trait_goals.rs @@ -5,8 +5,10 @@ use super::{EvalCtxt, SolverMode}; use rustc_hir::def_id::DefId; use rustc_hir::{LangItem, Movability}; use rustc_infer::traits::query::NoSolution; -use rustc_middle::traits::solve::inspect::CandidateKind; -use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, QueryResult}; +use rustc_middle::traits::solve::inspect::ProbeKind; +use rustc_middle::traits::solve::{ + CandidateSource, CanonicalResponse, Certainty, Goal, QueryResult, +}; use rustc_middle::traits::{BuiltinImplSource, Reveal}; use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams, TreatProjections}; use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt}; @@ -61,7 +63,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> { }, }; - ecx.probe_candidate("impl").enter(|ecx| { + ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| { let impl_args = ecx.fresh_args_for_item(impl_def_id); let impl_trait_ref = impl_trait_ref.instantiate(tcx, impl_args); @@ -96,7 +98,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> { && trait_clause.polarity() == goal.predicate.polarity { // FIXME: Constness - ecx.probe_candidate("assumption").enter(|ecx| { + ecx.probe_misc_candidate("assumption").enter(|ecx| { let assumption_trait_pred = ecx.instantiate_binder_with_infer(trait_clause); ecx.eq( goal.param_env, @@ -167,7 +169,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> { let tcx = ecx.tcx(); - ecx.probe_candidate("trait alias").enter(|ecx| { + ecx.probe_misc_candidate("trait alias").enter(|ecx| { let nested_obligations = tcx .predicates_of(goal.predicate.def_id()) .instantiate(tcx, goal.predicate.trait_ref.args); @@ -443,7 +445,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> { Err(NoSolution) => vec![], }; - ecx.probe(|_| CandidateKind::UnsizeAssembly).enter(|ecx| { + ecx.probe(|_| ProbeKind::UnsizeAssembly).enter(|ecx| { let a_ty = goal.predicate.self_ty(); // We need to normalize the b_ty since it's matched structurally // in the other functions below. @@ -630,7 +632,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { target_projection: ty::PolyExistentialProjection<'tcx>| { source_projection.item_def_id() == target_projection.item_def_id() && ecx - .probe(|_| CandidateKind::UpcastProbe) + .probe(|_| ProbeKind::UpcastProjectionCompatibility) .enter(|ecx| -> Result<(), NoSolution> { ecx.eq(param_env, source_projection, target_projection)?; let _ = ecx.try_evaluate_added_goals()?; @@ -908,7 +910,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> { goal: Goal<'tcx, TraitPredicate<'tcx>>, constituent_tys: impl Fn(&EvalCtxt<'_, 'tcx>, Ty<'tcx>) -> Result>, NoSolution>, ) -> QueryResult<'tcx> { - self.probe_candidate("constituent tys").enter(|ecx| { + self.probe_misc_candidate("constituent tys").enter(|ecx| { ecx.add_goals( constituent_tys(ecx, goal.predicate.self_ty())? .into_iter() diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs index e56af586ed875..1fc417cf8a716 100644 --- a/compiler/rustc_trait_selection/src/traits/coherence.rs +++ b/compiler/rustc_trait_selection/src/traits/coherence.rs @@ -204,18 +204,25 @@ fn overlap<'tcx>( // Equate the headers to find their intersection (the general type, with infer vars, // that may apply both impls). - let equate_obligations = equate_impl_headers(selcx.infcx, &impl1_header, &impl2_header)?; + let mut obligations = equate_impl_headers(selcx.infcx, &impl1_header, &impl2_header)?; debug!("overlap: unification check succeeded"); - if overlap_mode.use_implicit_negative() - && impl_intersection_has_impossible_obligation( - selcx, - param_env, - &impl1_header, - impl2_header, - equate_obligations, - ) - { + if !overlap_mode.use_implicit_negative() { + let impl_header = selcx.infcx.resolve_vars_if_possible(impl1_header); + return Some(OverlapResult { + impl_header, + intercrate_ambiguity_causes: Default::default(), + involves_placeholder: false, + }); + }; + + obligations.extend( + [&impl1_header.predicates, &impl2_header.predicates].into_iter().flatten().map( + |&predicate| Obligation::new(infcx.tcx, ObligationCause::dummy(), param_env, predicate), + ), + ); + + if impl_intersection_has_impossible_obligation(selcx, &obligations) { return None; } @@ -226,7 +233,12 @@ fn overlap<'tcx>( return None; } - let intercrate_ambiguity_causes = selcx.take_intercrate_ambiguity_causes(); + let intercrate_ambiguity_causes = if infcx.next_trait_solver() { + crate::solve::compute_intercrate_ambiguity_causes(&infcx, &obligations) + } else { + selcx.take_intercrate_ambiguity_causes() + }; + debug!("overlap: intercrate_ambiguity_causes={:#?}", intercrate_ambiguity_causes); let involves_placeholder = infcx .inner @@ -282,14 +294,11 @@ fn equate_impl_headers<'tcx>( /// Importantly, this works even if there isn't a `impl !Error for MyLocalType`. fn impl_intersection_has_impossible_obligation<'cx, 'tcx>( selcx: &mut SelectionContext<'cx, 'tcx>, - param_env: ty::ParamEnv<'tcx>, - impl1_header: &ty::ImplHeader<'tcx>, - impl2_header: ty::ImplHeader<'tcx>, - obligations: PredicateObligations<'tcx>, + obligations: &[PredicateObligation<'tcx>], ) -> bool { let infcx = selcx.infcx; - let obligation_guaranteed_to_fail = move |obligation: &PredicateObligation<'tcx>| { + let obligation_guaranteed_to_fail = move |obligation: &&PredicateObligation<'tcx>| { if infcx.next_trait_solver() { infcx.evaluate_obligation(obligation).map_or(false, |result| !result.may_apply()) } else { @@ -303,15 +312,7 @@ fn impl_intersection_has_impossible_obligation<'cx, 'tcx>( } }; - let opt_failing_obligation = [&impl1_header.predicates, &impl2_header.predicates] - .into_iter() - .flatten() - .map(|&predicate| { - Obligation::new(infcx.tcx, ObligationCause::dummy(), param_env, predicate) - }) - .chain(obligations) - .find(obligation_guaranteed_to_fail); - + let opt_failing_obligation = obligations.iter().find(obligation_guaranteed_to_fail); if let Some(failing_obligation) = opt_failing_obligation { debug!("overlap: obligation unsatisfiable {:?}", failing_obligation); true diff --git a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs index d3c4dc45923d9..197d3bedaaa01 100644 --- a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs +++ b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs @@ -22,6 +22,11 @@ impl<'tcx> StructurallyNormalizeExt<'tcx> for At<'_, 'tcx> { assert!(!ty.is_ty_var(), "should have resolved vars before calling"); if self.infcx.next_trait_solver() { + // FIXME(-Ztrait-solver=next): some calls to this function expect it to + // also try to normalize opaque types. We should probably make this + // configurable via an fn arg. + // + // Also, do we not have to deal with potential overflow here? while let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, projection_ty) = *ty.kind() {