rustc_next_trait_solver/canonical/

mod.rs

//! Canonicalization is used to separate some goal from its context,
//! throwing away unnecessary information in the process.
//!
//! This is necessary to cache goals containing inference variables
//! and placeholders without restricting them to the current `InferCtxt`.
//!
//! Canonicalization is fairly involved, for more details see the relevant
//! section of the [rustc-dev-guide][c].
//!
//! [c]: https://rustc-dev-guide.rust-lang.org/solve/canonicalization.html

use std::iter;

use canonicalizer::Canonicalizer;
use rustc_index::IndexVec;
use rustc_type_ir::inherent::*;
use rustc_type_ir::relate::{
    self, Relate, RelateResult, TypeRelation, VarianceDiagInfo, relate_args_invariantly,
};
use rustc_type_ir::{
    self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner, Region,
    TypeFoldable, TypingMode, TypingModeEqWrapper, eager_resolve_vars,
};
use thin_vec::ThinVec;
use tracing::instrument;

use crate::delegate::SolverDelegate;
use crate::solve::{
    CanonicalInput, CanonicalResponse, Certainty, ExternalConstraintsData,
    ExternalRegionConstraints, Goal, NestedNormalizationGoals, QueryInput, Response,
    VisibleForLeakCheck, inspect,
};

pub mod canonicalizer;

trait ResponseT<I: Interner> {
    fn var_values(&self) -> CanonicalVarValues<I>;
}

impl<I: Interner> ResponseT<I> for Response<I> {
    fn var_values(&self) -> CanonicalVarValues<I> {
        self.var_values
    }
}

impl<I: Interner, T> ResponseT<I> for inspect::State<I, T> {
    fn var_values(&self) -> CanonicalVarValues<I> {
        self.var_values
    }
}

/// Canonicalizes the goal remembering the original values
/// for each bound variable.
///
/// This expects `goal` and `opaque_types` to be eager resolved.
pub(super) fn canonicalize_goal<D, I>(
    delegate: &D,
    goal: Goal<I, I::Predicate>,
    opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
    typing_mode: TypingMode<I>,
) -> (ThinVec<I::GenericArg>, CanonicalInput<I, I::Predicate>)
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
{
    let (orig_values, canonical) = Canonicalizer::canonicalize_input(
        delegate,
        QueryInput {
            goal,
            predefined_opaques_in_body: delegate.cx().mk_predefined_opaques_in_body(opaque_types),
        },
    );

    let query_input =
        ty::CanonicalQueryInput { canonical, typing_mode: TypingModeEqWrapper(typing_mode) };
    (orig_values, query_input)
}

pub(super) fn canonicalize_response<D, I, T>(
    delegate: &D,
    max_input_universe: ty::UniverseIndex,
    value: T,
) -> ty::Canonical<I, T>
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
    T: TypeFoldable<I>,
{
    Canonicalizer::canonicalize_response(delegate, max_input_universe, value)
}

/// After calling a canonical query, we apply the constraints returned
/// by the query using this function.
///
/// This happens in three steps:
/// - we instantiate the bound variables of the query response
/// - we unify the `var_values` of the response with the `original_values`
/// - we apply the `external_constraints` returned by the query, returning
///   the `normalization_nested_goals`
pub(super) fn instantiate_and_apply_query_response<D, I>(
    delegate: &D,
    param_env: I::ParamEnv,
    original_values: &[I::GenericArg],
    response: CanonicalResponse<I>,
    span: I::Span,
) -> (NestedNormalizationGoals<I>, Certainty)
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
{
    let instantiation =
        compute_query_response_instantiation_values(delegate, &original_values, &response, span);

    let Response { var_values, external_constraints, certainty } =
        delegate.instantiate_canonical(response, instantiation);

    unify_query_var_values(delegate, param_env, &original_values, var_values, span);

    let ExternalConstraintsData { region_constraints, opaque_types, normalization_nested_goals } =
        &*external_constraints;

    match region_constraints {
        ExternalRegionConstraints::Old(r) => register_region_constraints(
            delegate,
            r.iter().map(|(c, vis)| {
                // FIXME: We should revisit and consider removing this after *assumptions on
                // binders* is available, like once we had done in the stabilization of
                // `-Znext-solver=coherence`(#121848).
                // We ignore constraints from the nested goals in leak check. This is to match with
                // the old solver's behavior, which has separated evaluation and fulfillment, and
                // the former doesn't consider outlives obligations from the later.
                (*c, vis.and(VisibleForLeakCheck::No))
            }),
            span,
        ),
        ExternalRegionConstraints::NextGen(r) => {
            delegate.register_solver_region_constraint(r.clone())
        }
    };
    register_new_opaque_types(delegate, opaque_types, span);

    (normalization_nested_goals.clone(), certainty)
}

/// This returns the canonical variable values to instantiate the bound variables of
/// the canonical response. This depends on the `original_values` for the
/// bound variables.
fn compute_query_response_instantiation_values<D, I, T>(
    delegate: &D,
    original_values: &[I::GenericArg],
    response: &Canonical<I, T>,
    span: I::Span,
) -> CanonicalVarValues<I>
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
    T: ResponseT<I>,
{
    // FIXME: Longterm canonical queries should deal with all placeholders
    // created inside of the query directly instead of returning them to the
    // caller.
    let prev_universe = delegate.universe();
    let universes_created_in_query = response.max_universe.index();
    for _ in 0..universes_created_in_query {
        let new_universe = delegate.create_next_universe();
        if delegate.cx().assumptions_on_binders() {
            // FIXME(-Zassumptions-on-binders): Remove this temporary workaround once
            // opaque types no longer escape query responses with query-created placeholders.
            // Region constraints involving query-created placeholders were handled inside
            // the query. However, the placeholders can still escape in other response
            // fields, such as opaque type constraints. To avoid triggering
            // assertions, we explicitly insert empty assumptions for the
            // recreated universes here.
            delegate.insert_placeholder_assumptions(
                new_universe,
                Some(rustc_type_ir::region_constraint::Assumptions::empty()),
            );
        }
    }

    compute_query_response_instantiation_values_in_universe(
        delegate,
        original_values,
        response,
        span,
        prev_universe,
    )
}

fn compute_query_response_instantiation_values_in_universe<D, I, T>(
    delegate: &D,
    original_values: &[I::GenericArg],
    response: &Canonical<I, T>,
    span: I::Span,
    prev_universe: ty::UniverseIndex,
) -> CanonicalVarValues<I>
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
    T: ResponseT<I>,
{
    let var_values = response.value.var_values();
    assert_eq!(original_values.len(), var_values.len());

    // If the query did not make progress with constraining inference variables,
    // we would normally create a new inference variables for bound existential variables
    // only then unify this new inference variable with the inference variable from
    // the input.
    //
    // We therefore instantiate the existential variable in the canonical response with the
    // inference variable of the input right away, which is more performant.
    let mut opt_values = IndexVec::from_elem_n(None, response.var_kinds.len());
    for (original_value, result_value) in iter::zip(original_values, var_values.var_values.iter()) {
        match result_value.kind() {
            ty::GenericArgKind::Type(t) => {
                // We disable the instantiation guess for inference variables
                // and only use it for placeholders. We need to handle the
                // `sub_root` of type inference variables which would make this
                // more involved. They are also a lot rarer than region variables.
                if let ty::Bound(index_kind, b) = t.kind()
                    && !matches!(
                        response.var_kinds.get(b.var().as_usize()).unwrap(),
                        CanonicalVarKind::Ty { .. }
                    )
                {
                    assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                    opt_values[b.var()] = Some(*original_value);
                }
            }
            ty::GenericArgKind::Lifetime(r) => {
                if let ty::ReBound(index_kind, br) = r.kind() {
                    assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                    opt_values[br.var()] = Some(*original_value);
                }
            }
            ty::GenericArgKind::Const(c) => {
                if let ty::ConstKind::Bound(index_kind, bc) = c.kind() {
                    assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                    opt_values[bc.var()] = Some(*original_value);
                }
            }
        }
    }
    CanonicalVarValues::instantiate(delegate.cx(), response.var_kinds, |var_values, kind| {
        if kind.universe() != ty::UniverseIndex::ROOT {
            // A variable from inside a binder of the query. While ideally these shouldn't
            // exist at all (see the FIXME at the start of this method), we have to deal with
            // them for now.
            delegate.instantiate_canonical_var(kind, span, &var_values, |idx| {
                prev_universe + idx.index()
            })
        } else if kind.is_existential() {
            // As an optimization we sometimes avoid creating a new inference variable here.
            //
            // All new inference variables we create start out in the current universe of the caller.
            // This is conceptually wrong as these inference variables would be able to name
            // more placeholders then they should be able to. However the inference variables have
            // to "come from somewhere", so by equating them with the original values of the caller
            // later on, we pull them down into their correct universe again.
            if let Some(v) = opt_values[ty::BoundVar::from_usize(var_values.len())] {
                v
            } else {
                delegate.instantiate_canonical_var(kind, span, &var_values, |_| prev_universe)
            }
        } else {
            // For placeholders which were already part of the input, we simply map this
            // universal bound variable back the placeholder of the input.
            //
            // For `CanonicalVarKind::PlaceholderRegion`, this differs slightly: we
            // canonicalize all free regions from the input into placeholders. This is
            // unlike types or consts, where only input placeholders remain placeholders
            // in the canonical form.
            //
            // We can still map these back to the original input regions, as we
            // just instantiate the canonical variable with its corresponding
            // `original_value`.
            //
            // For more information on why we canonicalize all input regions as
            // placeholders, see the comment in `Canonicalizer::fold_region`.
            original_values[kind.expect_placeholder_index()]
        }
    })
}

/// Enforce that `a` is equal to `b`.
///
/// In normal type relating, we don't structurally relate non-rigid aliases
/// as they can be normalized to any type. So we emit projection obligations to
/// defer the checks. E.g. in `infcx.eq` or `infcx.relate`.
/// But when unifying query response with original vars, we want to directly
/// set the original vars to values in response.
///
/// Therefore this type relation is created to **always** structurally relate
/// aliases, or more specifically, structurally eq everything.
struct ResponseRelating<'infcx, Infcx, I: Interner> {
    infcx: &'infcx Infcx,
    span: I::Span,
}

impl<'infcx, Infcx, I> ResponseRelating<'infcx, Infcx, I>
where
    Infcx: InferCtxtLike<Interner = I>,
    I: Interner,
{
    fn new(infcx: &'infcx Infcx, span: I::Span) -> Self {
        ResponseRelating { infcx, span }
    }
}

impl<Infcx, I> TypeRelation<I> for ResponseRelating<'_, Infcx, I>
where
    Infcx: InferCtxtLike<Interner = I>,
    I: Interner,
{
    fn cx(&self) -> I {
        self.infcx.cx()
    }

    fn relate_ty_args(
        &mut self,
        a_ty: I::Ty,
        _b_ty: I::Ty,
        _def_id: I::DefId,
        a_args: I::GenericArgs,
        b_args: I::GenericArgs,
        _: impl FnOnce(I::GenericArgs) -> I::Ty,
    ) -> RelateResult<I, I::Ty> {
        relate_args_invariantly(self, a_args, b_args)?;
        Ok(a_ty)
    }

    fn relate_with_variance<T: Relate<I>>(
        &mut self,
        _variance: ty::Variance,
        _info: VarianceDiagInfo<I>,
        a: T,
        b: T,
    ) -> RelateResult<I, T> {
        self.relate(a, b)
    }

    #[instrument(skip(self), level = "trace")]
    fn tys(&mut self, a: I::Ty, b: I::Ty) -> RelateResult<I, I::Ty> {
        if a == b {
            return Ok(a);
        }

        let infcx = self.infcx;
        let a = infcx.shallow_resolve(a);
        let b = infcx.shallow_resolve(b);

        match (a.kind(), b.kind()) {
            (ty::Infer(ty::TyVar(a_id)), ty::Infer(ty::TyVar(b_id))) => {
                infcx.equate_ty_vids_raw(a_id, b_id);
            }

            (ty::Infer(ty::TyVar(a_vid)), _) => {
                infcx.instantiate_ty_var_raw(a_vid, b);
            }

            (_, ty::Infer(ty::TyVar(b_vid))) => {
                infcx.instantiate_ty_var_raw(b_vid, a);
            }

            (ty::Error(e), _) | (_, ty::Error(e)) => {
                infcx.set_tainted_by_errors(e);
                return Ok(Ty::new_error(infcx.cx(), e));
            }

            // FIXME: Share the arms below with `super_combine_tys`.
            // We can't use `super_combine_tys` here because we want to support
            // values with escaping bound vars so that we can avoid
            // instantiating binders when relating them.
            //
            // Relate integral variables to other types
            (ty::Infer(ty::IntVar(a_id)), ty::Infer(ty::IntVar(b_id))) => {
                infcx.equate_int_vids_raw(a_id, b_id);
            }
            (ty::Infer(ty::IntVar(v_id)), ty::Int(v)) => {
                infcx.instantiate_int_var_raw(v_id, ty::IntVarValue::IntType(v));
            }
            (ty::Int(v), ty::Infer(ty::IntVar(v_id))) => {
                infcx.instantiate_int_var_raw(v_id, ty::IntVarValue::IntType(v));
            }
            (ty::Infer(ty::IntVar(v_id)), ty::Uint(v)) => {
                infcx.instantiate_int_var_raw(v_id, ty::IntVarValue::UintType(v));
            }
            (ty::Uint(v), ty::Infer(ty::IntVar(v_id))) => {
                infcx.instantiate_int_var_raw(v_id, ty::IntVarValue::UintType(v));
            }

            // Relate floating-point variables to other types
            (ty::Infer(ty::FloatVar(a_id)), ty::Infer(ty::FloatVar(b_id))) => {
                infcx.equate_float_vids_raw(a_id, b_id);
            }
            (ty::Infer(ty::FloatVar(v_id)), ty::Float(v)) => {
                infcx.instantiate_float_var_raw(v_id, ty::FloatVarValue::Known(v));
            }
            (ty::Float(v), ty::Infer(ty::FloatVar(v_id))) => {
                infcx.instantiate_float_var_raw(v_id, ty::FloatVarValue::Known(v));
            }

            (_, ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)))
            | (ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)), _) => {
                panic!("We do not expect to encounter `Fresh` variables in the new solver")
            }

            _ => {
                relate::structurally_relate_tys(self, a, b)?;
            }
        }

        Ok(a)
    }

    #[instrument(skip(self), level = "trace")]
    fn regions(&mut self, a: Region<I>, b: Region<I>) -> RelateResult<I, Region<I>> {
        self.infcx.equate_regions(a, b, VisibleForLeakCheck::Yes, self.span);

        Ok(a)
    }

    #[instrument(skip(self), level = "trace")]
    fn consts(&mut self, a: I::Const, b: I::Const) -> RelateResult<I, I::Const> {
        if a == b {
            return Ok(a);
        }

        let infcx = self.infcx;
        // Proof tree evaluation can unify inference variables in the original
        // values without eagerly resolving them.
        let a = infcx.shallow_resolve_const(a);
        let b = infcx.shallow_resolve_const(b);
        match (a.kind(), b.kind()) {
            (
                ty::ConstKind::Infer(ty::InferConst::Var(a_vid)),
                ty::ConstKind::Infer(ty::InferConst::Var(b_vid)),
            ) => {
                infcx.equate_const_vids_raw(a_vid, b_vid);
            }

            (ty::ConstKind::Infer(ty::InferConst::Var(a_vid)), _) => {
                infcx.instantiate_const_var_raw(a_vid, b);
            }

            (_, ty::ConstKind::Infer(ty::InferConst::Var(b_vid))) => {
                infcx.instantiate_const_var_raw(b_vid, a);
            }

            _ => {
                relate::structurally_relate_consts(self, a, b)?;
            }
        }

        Ok(a)
    }

    fn binders<T>(
        &mut self,
        a: ty::Binder<I, T>,
        b: ty::Binder<I, T>,
    ) -> RelateResult<I, ty::Binder<I, T>>
    where
        T: Relate<I>,
    {
        if a == b {
            return Ok(a);
        }

        debug_assert_eq!(a.bound_vars(), b.bound_vars());
        self.relate(a.skip_binder(), b.skip_binder())?;

        Ok(a)
    }
}

/// Unify the `original_values` with the `var_values` returned by the canonical query..
///
/// This assumes that this unification will always succeed. This is the case when
/// applying a query response right away. However, calling a canonical query, doing any
/// other kind of trait solving, and only then instantiating the result of the query
/// can cause the instantiation to fail. This is not supported and we ICE in this case.
///
/// We always structurally instantiate aliases. Relating aliases needs to be different
/// depending on whether the alias is *rigid* or not. We're only really able to tell
/// whether an alias is rigid by using the trait solver. When instantiating a response
/// from the solver we assume that the solver correctly handled aliases and therefore
/// always relate them structurally here.
#[instrument(level = "trace", skip(delegate))]
fn unify_query_var_values<D, I>(
    delegate: &D,
    param_env: I::ParamEnv,
    original_values: &[I::GenericArg],
    var_values: CanonicalVarValues<I>,
    span: I::Span,
) where
    D: SolverDelegate<Interner = I>,
    I: Interner,
{
    assert_eq!(original_values.len(), var_values.len());

    for (&orig, response) in iter::zip(original_values, var_values.var_values.iter()) {
        let mut must_eq = ResponseRelating::new(&**delegate, span);
        must_eq.relate(orig, response).unwrap();
    }
}

fn register_region_constraints<D, I>(
    delegate: &D,
    constraints: impl IntoIterator<Item = (ty::RegionConstraint<I>, VisibleForLeakCheck)>,
    span: I::Span,
) where
    D: SolverDelegate<Interner = I>,
    I: Interner,
{
    for (constraint, vis) in constraints {
        match constraint {
            ty::RegionConstraint::Outlives(ty::OutlivesClause(lhs, rhs)) => match lhs.kind() {
                ty::GenericArgKind::Lifetime(lhs) => delegate.sub_regions(rhs, lhs, vis, span),
                ty::GenericArgKind::Type(lhs) => delegate.register_ty_outlives(lhs, rhs, span),
                ty::GenericArgKind::Const(_) => panic!("const outlives: {lhs:?}: {rhs:?}"),
            },
            ty::RegionConstraint::Eq(ty::RegionEqPredicate(lhs, rhs)) => {
                delegate.equate_regions(lhs, rhs, vis, span)
            }
        }
    }
}

fn register_new_opaque_types<D, I>(
    delegate: &D,
    opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
    span: I::Span,
) where
    D: SolverDelegate<Interner = I>,
    I: Interner,
{
    for &(key, ty) in opaque_types {
        let prev = delegate.register_hidden_type_in_storage(key, ty, span);
        // We eagerly resolve inference variables when computing the query response.
        // This can cause previously distinct opaque type keys to now be structurally equal.
        //
        // To handle this, we store any duplicate entries in a separate list to check them
        // at the end of typeck/borrowck. We could alternatively eagerly equate the hidden
        // types here. However, doing so is difficult as it may result in nested goals and
        // any errors may make it harder to track the control flow for diagnostics.
        if let Some(prev) = prev {
            delegate.add_duplicate_opaque_type(key, prev, span);
        }
    }
}

/// Used by proof trees to be able to recompute intermediate actions while
/// evaluating a goal. The `var_values` not only include the bound variables
/// of the query input, but also contain all unconstrained inference vars
/// created while evaluating this goal.
pub fn make_canonical_state<D, I, T>(
    delegate: &D,
    var_values: &[I::GenericArg],
    max_input_universe: ty::UniverseIndex,
    data: T,
) -> inspect::CanonicalState<I, T>
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
    T: TypeFoldable<I>,
{
    let var_values = CanonicalVarValues { var_values: delegate.cx().mk_args(var_values) };
    let state = inspect::State { var_values, data };
    let state = eager_resolve_vars(&**delegate, state);
    Canonicalizer::canonicalize_response(delegate, max_input_universe, state)
}

// FIXME: needs to be pub to be accessed by downstream
// `rustc_trait_selection::solve::inspect::analyse`.
pub fn instantiate_canonical_state<D, I, T>(
    delegate: &D,
    span: I::Span,
    param_env: I::ParamEnv,
    prev_universe: ty::UniverseIndex,
    orig_values: &mut ThinVec<I::GenericArg>,
    state: inspect::CanonicalState<I, T>,
) -> T
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
    T: TypeFoldable<I>,
{
    // In case any fresh inference variables have been created between `state`
    // and the previous instantiation, extend `orig_values` for it.
    let max_universe = prev_universe + state.max_universe.index();
    while delegate.universe() < max_universe {
        delegate.create_next_universe();
    }
    orig_values.extend(
        state.value.var_values.var_values.as_slice()[orig_values.len()..]
            .iter()
            .map(|&arg| delegate.fresh_var_for_kind(arg, span, max_universe)),
    );

    let instantiation = compute_query_response_instantiation_values_in_universe(
        delegate,
        orig_values,
        &state,
        span,
        prev_universe,
    );

    let inspect::State { var_values, data } = delegate.instantiate_canonical(state, instantiation);

    unify_query_var_values(delegate, param_env, orig_values, var_values, span);
    data
}

pub fn response_no_constraints_raw<I: Interner>(
    cx: I,
    max_universe: ty::UniverseIndex,
    var_kinds: I::CanonicalVarKinds,
    certainty: Certainty,
) -> CanonicalResponse<I> {
    ty::Canonical {
        max_universe,
        var_kinds,
        value: Response {
            var_values: ty::CanonicalVarValues::make_identity(cx, var_kinds),
            // FIXME: maybe we should store the "no response" version in cx, like
            // we do for cx.types and stuff.
            external_constraints: cx.mk_external_constraints(ExternalConstraintsData::new(cx)),
            certainty,
        },
    }
}