Only prefer param-env candidates if they remain non-global after norm

Author: compiler-errors

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

@@ -2,21 +2,24 @@
 
 pub(super)mod structural_traits;
 
+use std::ops::ControlFlow;
+
 use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
 use rustc_type_ir::{
-selfas ty,Interner,TypeFoldable,TypeVisitableExtas _,TypingMode,Upcastas _, elaborate,
+selfas ty,Interner,TypeFoldable,TypeSuperVisitable,TypeVisitable,TypeVisitableExtas _,
+TypeVisitor,TypingMode,Upcastas _, elaborate,
 };
 use tracing::{debug, instrument};
 
-usesuper::has_only_region_constraints;
 usesuper::trait_goals::TraitGoalProvenVia;
+usesuper::{has_only_region_constraints, inspect};
 usecrate::delegate::SolverDelegate;
 usecrate::solve::inspect::ProbeKind;
 usecrate::solve::{
 BuiltinImplSource,CandidateSource,CanonicalResponse,Certainty,EvalCtxt,Goal,GoalSource,
-MaybeCause,NoSolution,QueryResult,
+MaybeCause,NoSolution,ParamEnvSource,QueryResult,
 };
 
 enumAliasBoundKind{
@@ -49,18 +52,6 @@ where
 
 fntrait_def_id(self,cx:I) -> I::DefId;
 
-/// Try equating an assumption predicate against a goal's predicate. If it
-/// holds, then execute the `then` callback, which should do any additional
-/// work, then produce a response (typically by executing
-/// [`EvalCtxt::evaluate_added_goals_and_make_canonical_response`]).
-fnprobe_and_match_goal_against_assumption(
-ecx:&mutEvalCtxt<'_,D>,
-source:CandidateSource<I>,
-goal:Goal<I,Self>,
-assumption:I::Clause,
-then:implFnOnce(&mutEvalCtxt<'_,D>) -> QueryResult<I>,
-) -> Result<Candidate<I>,NoSolution>;
-
 /// Consider a clause, which consists of a "assumption" and some "requirements",
 /// to satisfy a goal. If the requirements hold, then attempt to satisfy our
 /// goal by equating it with the assumption.
@@ -119,6 +110,67 @@ where
 alias_ty: ty::AliasTy<I>,
 ) -> Vec<Candidate<I>>;
 
+fnprobe_and_consider_param_env_candidate(
+ecx:&mutEvalCtxt<'_,D>,
+goal:Goal<I,Self>,
+assumption:I::Clause,
+) -> Result<Candidate<I>,NoSolution>{
+Self::fast_reject_assumption(ecx, goal, assumption)?;
+
+ ecx.probe(|candidate:&Result<Candidate<I>,NoSolution>| match candidate {
+Ok(candidate) => inspect::ProbeKind::TraitCandidate{
+source: candidate.source,
+result:Ok(candidate.result),
+},
+Err(NoSolution) => inspect::ProbeKind::TraitCandidate{
+source:CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
+result:Err(NoSolution),
+},
+})
+.enter(|ecx| {
+Self::match_assumption(ecx, goal, assumption)?;
+let source = ecx.characterize_param_env_assumption(goal.param_env, assumption)?;
+Ok(Candidate{
+ source,
+result: ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)?,
+})
+})
+}
+
+/// Try equating an assumption predicate against a goal's predicate. If it
+/// holds, then execute the `then` callback, which should do any additional
+/// work, then produce a response (typically by executing
+/// [`EvalCtxt::evaluate_added_goals_and_make_canonical_response`]).
+fnprobe_and_match_goal_against_assumption(
+ecx:&mutEvalCtxt<'_,D>,
+source:CandidateSource<I>,
+goal:Goal<I,Self>,
+assumption:I::Clause,
+then:implFnOnce(&mutEvalCtxt<'_,D>) -> QueryResult<I>,
+) -> Result<Candidate<I>,NoSolution>{
+Self::fast_reject_assumption(ecx, goal, assumption)?;
+
+ ecx.probe_trait_candidate(source).enter(|ecx| {
+Self::match_assumption(ecx, goal, assumption)?;
+then(ecx)
+})
+}
+
+/// Try to reject the assumption based off of simple heuristics, such as [`ty::ClauseKind`]
+/// and [`I::DefId`].
+fnfast_reject_assumption(
+ecx:&mutEvalCtxt<'_,D>,
+goal:Goal<I,Self>,
+assumption:I::Clause,
+) -> Result<(),NoSolution>;
+
+/// Relate the goal and assumption.
+fnmatch_assumption(
+ecx:&mutEvalCtxt<'_,D>,
+goal:Goal<I,Self>,
+assumption:I::Clause,
+) -> Result<(),NoSolution>;
+
 fnconsider_impl_candidate(
 ecx:&mutEvalCtxt<'_,D>,
 goal:Goal<I,Self>,
@@ -500,14 +552,8 @@ where
 goal:Goal<I,G>,
 candidates:&mutVec<Candidate<I>>,
 ){
-for(i, assumption)in goal.param_env.caller_bounds().iter().enumerate(){
- candidates.extend(G::probe_and_consider_implied_clause(
-self,
-CandidateSource::ParamEnv(i),
- goal,
- assumption,
-[],
-));
+for assumption in goal.param_env.caller_bounds().iter(){
+ candidates.extend(G::probe_and_consider_param_env_candidate(self, goal, assumption));
 }
 }
 
@@ -943,4 +989,76 @@ where
 }
 }
 }
+
+fncharacterize_param_env_assumption(
+&mutself,
+param_env:I::ParamEnv,
+assumption:I::Clause,
+) -> Result<CandidateSource<I>,NoSolution>{
+// FIXME:
+if assumption.has_bound_vars(){
+returnOk(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal));
+}
+
+match assumption.visit_with(&mutFindParamInClause{ecx:self, param_env }){
+ControlFlow::Break(Err(NoSolution)) => Err(NoSolution),
+ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)),
+ControlFlow::Continue(()) => Ok(CandidateSource::ParamEnv(ParamEnvSource::Global)),
+}
+}
+}
+
+structFindParamInClause<'a,'b,D:SolverDelegate<Interner = I>,I:Interner>{
+ecx:&'amutEvalCtxt<'b,D>,
+param_env:I::ParamEnv,
+}
+
+impl<D,I>TypeVisitor<I>forFindParamInClause<'_,'_,D,I>
+where
+D:SolverDelegate<Interner = I>,
+I:Interner,
+{
+typeResult = ControlFlow<Result<(),NoSolution>>;
+
+fnvisit_binder<T:TypeFoldable<I>>(&mutself,t:&ty::Binder<I,T>) -> Self::Result{
+self.ecx.enter_forall(t.clone(), |ecx, v| {
+ v.visit_with(&mutFindParamInClause{ ecx,param_env:self.param_env})
+})
+}
+
+fnvisit_ty(&mutself,ty:I::Ty) -> Self::Result{
+letOk(ty) = self.ecx.structurally_normalize_ty(self.param_env, ty)else{
+returnControlFlow::Break(Err(NoSolution));
+};
+let ty = self.ecx.eager_resolve(ty);
+
+iflet ty::Placeholder(_) = ty.kind(){
+ControlFlow::Break(Ok(()))
+}else{
+ ty.super_visit_with(self)
+}
+}
+
+fnvisit_const(&mutself,ct:I::Const) -> Self::Result{
+letOk(ct) = self.ecx.structurally_normalize_const(self.param_env, ct)else{
+returnControlFlow::Break(Err(NoSolution));
+};
+let ct = self.ecx.eager_resolve(ct);
+
+iflet ty::ConstKind::Placeholder(_) = ct.kind(){
+ControlFlow::Break(Ok(()))
+}else{
+ ct.super_visit_with(self)
+}
+}
+
+fnvisit_region(&mutself,r:I::Region) -> Self::Result{
+match r.kind(){
+ ty::ReStatic | ty::ReError(_) => ControlFlow::Continue(()),
+ ty::ReVar(_) | ty::RePlaceholder(_) => ControlFlow::Break(Ok(())),
+ ty::ReErased | ty::ReEarlyParam(_) | ty::ReLateParam(_) | ty::ReBound(..) => {
+unreachable!()
+}
+}
+}
 }

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -36,39 +36,40 @@ where
 self.def_id()
 }
 
-fnprobe_and_match_goal_against_assumption(
+fnfast_reject_assumption(
 ecx:&mutEvalCtxt<'_,D>,
-source: rustc_type_ir::solve::CandidateSource<I>,
 goal:Goal<I,Self>,
-assumption: <IasInterner>::Clause,
-then:implFnOnce(&mutEvalCtxt<'_,D>) -> QueryResult<I>,
-) -> Result<Candidate<I>,NoSolution>{
+assumption:I::Clause,
+) -> Result<(),NoSolution>{
 ifletSome(host_clause) = assumption.as_host_effect_clause(){
 if host_clause.def_id() == goal.predicate.def_id()
  && host_clause.constness().satisfies(goal.predicate.constness)
 {
-if!DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
+ifDeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
  goal.predicate.trait_ref.args,
  host_clause.skip_binder().trait_ref.args,
 ){
-returnErr(NoSolution);
+returnOk(());
 }
-
- ecx.probe_trait_candidate(source).enter(|ecx| {
-let assumption_trait_pred = ecx.instantiate_binder_with_infer(host_clause);
- ecx.eq(
- goal.param_env,
- goal.predicate.trait_ref,
- assumption_trait_pred.trait_ref,
-)?;
-then(ecx)
-})
-}else{
-Err(NoSolution)
 }
-}else{
-Err(NoSolution)
 }
+
+Err(NoSolution)
+}
+
+fnmatch_assumption(
+ecx:&mutEvalCtxt<'_,D>,
+goal:Goal<I,Self>,
+assumption:I::Clause,
+) -> Result<(),NoSolution>{
+letSome(host_clause) = assumption.as_host_effect_clause()else{
+panic!("fast_reject_assumption should have avoided this");
+};
+
+let assumption_trait_pred = ecx.instantiate_binder_with_infer(host_clause);
+ ecx.eq(goal.param_env, goal.predicate.trait_ref, assumption_trait_pred.trait_ref)?;
+
+Ok(())
 }
 
 /// Register additional assumptions for aliases corresponding to `~const` item bounds.
@@ -124,7 +125,7 @@ where
 fnconsider_impl_candidate(
 ecx:&mutEvalCtxt<'_,D>,
 goal:Goal<I,Self>,
-impl_def_id:<IasInterner>::DefId,
+impl_def_id:I::DefId,
 ) -> Result<Candidate<I>,NoSolution>{
 let cx = ecx.cx();
 
@@ -178,7 +179,7 @@ where
 
 fnconsider_error_guaranteed_candidate(
 ecx:&mutEvalCtxt<'_,D>,
-_guar:<IasInterner>::ErrorGuaranteed,
+_guar:I::ErrorGuaranteed,
 ) -> Result<Candidate<I>,NoSolution>{
  ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc)
 .enter(|ecx| ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes))

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

@@ -19,6 +19,7 @@ use tracing::{debug, instrument, trace};
 usesuper::has_only_region_constraints;
 usecrate::coherence;
 usecrate::delegate::SolverDelegate;
+usecrate::resolve::EagerResolver;
 usecrate::solve::inspect::{self,ProofTreeBuilder};
 usecrate::solve::search_graph::SearchGraph;
 usecrate::solve::{
@@ -1000,6 +1001,13 @@ where
 self.delegate.resolve_vars_if_possible(value)
 }
 
+pub(super)fneager_resolve<T>(&self,value:T) -> T
+where
+T:TypeFoldable<I>,
+{
+ value.fold_with(&mutEagerResolver::new(self.delegate))
+}
+
 pub(super)fnfresh_args_for_item(&mutself,def_id:I::DefId) -> I::GenericArgs{
 let args = self.delegate.fresh_args_for_item(def_id);
 for arg in args.iter(){

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

@@ -106,50 +106,50 @@ where
 self.trait_def_id(cx)
 }
 
-fnprobe_and_match_goal_against_assumption(
+fnfast_reject_assumption(
 ecx:&mutEvalCtxt<'_,D>,
-source:CandidateSource<I>,
 goal:Goal<I,Self>,
 assumption:I::Clause,
-then:implFnOnce(&mutEvalCtxt<'_,D>) -> QueryResult<I>,
-) -> Result<Candidate<I>,NoSolution>{
+) -> Result<(),NoSolution>{
 ifletSome(projection_pred) = assumption.as_projection_clause(){
 if projection_pred.item_def_id() == goal.predicate.def_id(){
-let cx = ecx.cx();
-if !DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
+ifDeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
  goal.predicate.alias.args,
  projection_pred.skip_binder().projection_term.args,
 ){
-returnErr(NoSolution);
+returnOk(());
 }
- ecx.probe_trait_candidate(source).enter(|ecx| {
-let assumption_projection_pred =
- ecx.instantiate_binder_with_infer(projection_pred);
- ecx.eq(
- goal.param_env,
- goal.predicate.alias,
- assumption_projection_pred.projection_term,
-)?;
-
- ecx.instantiate_normalizes_to_term(goal, assumption_projection_pred.term);
-
-// Add GAT where clauses from the trait's definition
-// FIXME: We don't need these, since these are the type's own WF obligations.
- ecx.add_goals(
-GoalSource::AliasWellFormed,
- cx.own_predicates_of(goal.predicate.def_id())
-.iter_instantiated(cx, goal.predicate.alias.args)
-.map(|pred| goal.with(cx, pred)),
-);
-
-then(ecx)
-})
-}else{
-Err(NoSolution)
 }
-}else{
-Err(NoSolution)
 }
+
+Err(NoSolution)
+}
+
+fnmatch_assumption(
+ecx:&mutEvalCtxt<'_,D>,
+goal:Goal<I,Self>,
+assumption:I::Clause,
+) -> Result<(),NoSolution>{
+letSome(projection_pred) = assumption.as_projection_clause()else{
+panic!("fast_reject_assumption should have avoided this");
+};
+
+let assumption_projection_pred = ecx.instantiate_binder_with_infer(projection_pred);
+ ecx.eq(goal.param_env, goal.predicate.alias, assumption_projection_pred.projection_term)?;
+
+ ecx.instantiate_normalizes_to_term(goal, assumption_projection_pred.term);
+
+// Add GAT where clauses from the trait's definition
+// FIXME: We don't need these, since these are the type's own WF obligations.
+let cx = ecx.cx();
+ ecx.add_goals(
+GoalSource::AliasWellFormed,
+ cx.own_predicates_of(goal.predicate.def_id())
+.iter_instantiated(cx, goal.predicate.alias.args)
+.map(|pred| goal.with(cx, pred)),
+);
+
+Ok(())
 }
 
 fnconsider_additional_alias_assumptions(