1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

//! Computes a normalizes-to (projection) goal for inherent associated types,
//! `#![feature(lazy_type_alias)]` and `#![feature(type_alias_impl_trait)]`.
//!
//! Since a weak alias is never ambiguous, this just computes the `type_of` of
//! the alias and registers the where-clauses of the type alias.

use rustc_type_ir::{self as ty, Interner};

use crate::infcx::SolverDelegate;
use crate::solve::{Certainty, EvalCtxt, Goal, GoalSource, QueryResult};

impl<Infcx, I> EvalCtxt<'_, Infcx>
where
    Infcx: SolverDelegate<Interner = I>,
    I: Interner,
{
    pub(super) fn normalize_weak_type(
        &mut self,
        goal: Goal<I, ty::NormalizesTo<I>>,
    ) -> QueryResult<I> {
        let tcx = self.interner();
        let weak_ty = goal.predicate.alias;

        // Check where clauses
        self.add_goals(
            GoalSource::Misc,
            tcx.predicates_of(weak_ty.def_id)
                .iter_instantiated(tcx, &weak_ty.args)
                .map(|pred| goal.with(tcx, pred)),
        );

        let actual = tcx.type_of(weak_ty.def_id).instantiate(tcx, &weak_ty.args);
        self.instantiate_normalizes_to_term(goal, actual.into());

        self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
    }
}