GoalKind in rustc_next_trait_solver::solve::assembly - Rust (original) (raw)
pub(super) trait GoalKind<D, I = I>:
TypeFoldable<I>
+ Copy
+ Eq
+ Display
where
D: SolverDelegate<Interner = I>,
I: Interner,
{
Show 33 methods // Required methods
fn self_ty(self) -> I::Ty;
fn trait_ref(self, cx: I) -> TraitRef<I>;
fn with_self_ty(self, cx: I, self_ty: I::Ty) -> Self;
fn trait_def_id(self, cx: I) -> I::DefId;
fn consider_additional_alias_assumptions(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
alias_ty: AliasTy<I>,
) -> Vec<Candidate<I>>;
fn fast_reject_assumption(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<(), NoSolution>;
fn match_assumption(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
assumption: I::Clause,
then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
) -> QueryResult<I>;
fn consider_impl_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
impl_def_id: I::DefId,
) -> Result<Candidate<I>, NoSolution>;
fn consider_error_guaranteed_candidate(
ecx: &mut EvalCtxt<'_, D>,
guar: I::ErrorGuaranteed,
) -> Result<Candidate<I>, NoSolution>;
fn consider_auto_trait_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_trait_alias_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_sized_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_copy_clone_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_fn_ptr_trait_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_fn_trait_candidates(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
kind: ClosureKind,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_async_fn_trait_candidates(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
kind: ClosureKind,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_async_fn_kind_helper_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_tuple_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_pointee_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_future_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_iterator_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_fused_iterator_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_async_iterator_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_coroutine_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_discriminant_kind_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_destruct_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_transmute_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_bikeshed_guaranteed_no_drop_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_structural_builtin_unsize_candidates(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Vec<Candidate<I>>;
// Provided methods
fn probe_and_consider_implied_clause(
ecx: &mut EvalCtxt<'_, D>,
parent_source: CandidateSource<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
requirements: impl IntoIterator<Item = (GoalSource, Goal<I, I::Predicate>)>,
) -> Result<Candidate<I>, NoSolution> { ... }
fn probe_and_consider_object_bound_candidate(
ecx: &mut EvalCtxt<'_, D>,
source: CandidateSource<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<Candidate<I>, NoSolution> { ... }
fn probe_and_consider_param_env_candidate(
ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<Candidate<I>, NoSolution> { ... }
fn probe_and_match_goal_against_assumption(
ecx: &mut EvalCtxt<'_, D>,
source: CandidateSource<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
) -> Result<Candidate<I>, NoSolution> { ... }
}Expand description
Methods used to assemble candidates for either trait or projection goals.
Assemble additional assumptions for an alias that are not included in the item bounds of the alias. For now, this is limited to theexplicit_implied_const_bounds for an associated type.
Try to reject the assumption based off of simple heuristics, such as ty::ClauseKindand DefId.
Relate the goal and assumption.
If the predicate contained an error, we want to avoid emitting unnecessary trait errors but still want to emit errors for other trait goals. We have some special handling for this case.
Trait goals always hold while projection goals never do. This is a bit arbitrary but prevents incorrect normalization while hiding any trait errors.
A trait alias holds if the RHS traits and where clauses hold.
A type is a FnPtr if it is of FnPtr type.
A callable type (a closure, fn def, or fn ptr) is known to implement the Fn<A>family of traits where A is given by the signature of the type.
An async closure is known to implement the AsyncFn<A> family of traits where A is given by the signature of the type.
Compute the built-in logic of the AsyncFnKindHelper helper trait, which is used internally to delay computation for async closures until after upvar analysis is performed in HIR typeck.
Tuple is implemented if the Self type is a tuple.
Pointee is always implemented.
See the projection implementation for the Metadata types for all of the built-in types. For structs, the metadata type is given by the struct tail.
A coroutine (that comes from an async desugaring) is known to implementFuture<Output = O>, where O is given by the coroutine’s return type that was computed during type-checking.
A coroutine (that comes from a gen desugaring) is known to implementIterator<Item = O>, where O is given by the generator’s yield type that was computed during type-checking.
A coroutine (that comes from a gen desugaring) is known to implementFusedIterator
A coroutine (that doesn’t come from an async or gen desugaring) is known to implement Coroutine<R, Yield = Y, Return = O>, given the resume, yield, and return types of the coroutine computed during type-checking.
Consider (possibly several) candidates to upcast or unsize a type to another type, excluding the coercion of a sized type into a dyn Trait.
We return the BuiltinImplSource for each candidate as it is needed for unsize coercion in hir typeck and because it is difficult to otherwise recompute this for codegen. This is a bit of a mess but the easiest way to maintain the existing behavior for now.
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.
Consider a clause specifically for a dyn Trait self type. This requires additionally checking all of the supertraits and object bounds to hold, since they’re not implied by the well-formedness of the object type.
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 executingEvalCtxt::evaluate_added_goals_and_make_canonical_response).
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.