add unused NormalizesTo predicate

Author: lcnr

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -657,19 +657,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  | ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(..))
  | ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(..))
  | ty::PredicateKind::ObjectSafe(..)
+ | ty::PredicateKind::NormalizesTo(..)
  | ty::PredicateKind::AliasRelate(..)
  | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
  | ty::PredicateKind::ConstEquate(..)
- // N.B., this predicate is created by breaking down a
- // `ClosureType: FnFoo()` predicate, where
- // `ClosureType` represents some `Closure`. It can't
- // possibly be referring to the current closure,
- // because we haven't produced the `Closure` for
- // this closure yet; this is exactly why the other
- // code is looking for a self type of an unresolved
- // inference variable.
- | ty::PredicateKind::Ambiguous
- => None,
+ | ty::PredicateKind::Ambiguous => None,
  },
  )
  }

compiler/rustc_infer/src/traits/util.rs

@@ -261,9 +261,14 @@ impl<'tcx, O: Elaboratable<'tcx>> Elaborator<'tcx, O> {
  fn elaborate(&mut self, elaboratable: &O) {
  let tcx = self.visited.tcx;
 
- let bound_predicate = elaboratable.predicate().kind();
- match bound_predicate.skip_binder() {
- ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
+ // We only elaborate clauses.
+ let Some(clause) = elaboratable.predicate().as_clause() else {
+ return;
+ };
+
+ let bound_clause = clause.kind();
+ match bound_clause.skip_binder() {
+ ty::ClauseKind::Trait(data) => {
  // Negative trait bounds do not imply any supertrait bounds
  if data.polarity == ty::ImplPolarity::Negative {
  return;
@@ -280,49 +285,16 @@ impl<'tcx, O: Elaboratable<'tcx>> Elaborator<'tcx, O> {
  let obligations =
  predicates.predicates.iter().enumerate().map(|(index, &(clause, span))| {
  elaboratable.child_with_derived_cause(
- clause.subst_supertrait(tcx, &bound_predicate.rebind(data.trait_ref)),
+ clause.subst_supertrait(tcx, &bound_clause.rebind(data.trait_ref)),
  span,
- bound_predicate.rebind(data),
+ bound_clause.rebind(data),
  index,
  )
  });
  debug!(?data, ?obligations, "super_predicates");
  self.extend_deduped(obligations);
  }
- ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(..)) => {
- // Currently, we do not elaborate WF predicates,
- // although we easily could.
- }
- ty::PredicateKind::ObjectSafe(..) => {
- // Currently, we do not elaborate object-safe
- // predicates.
- }
- ty::PredicateKind::Subtype(..) => {
- // Currently, we do not "elaborate" predicates like `X <: Y`,
- // though conceivably we might.
- }
- ty::PredicateKind::Coerce(..) => {
- // Currently, we do not "elaborate" predicates like `X -> Y`,
- // though conceivably we might.
- }
- ty::PredicateKind::Clause(ty::ClauseKind::Projection(..)) => {
- // Nothing to elaborate in a projection predicate.
- }
- ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..)) => {
- // Currently, we do not elaborate const-evaluatable
- // predicates.
- }
- ty::PredicateKind::ConstEquate(..) => {
- // Currently, we do not elaborate const-equate
- // predicates.
- }
- ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(..)) => {
- // Nothing to elaborate from `'a: 'b`.
- }
- ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(
- ty_max,
- r_min,
- ))) => {
+ ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(ty_max, r_min)) => {
  // We know that `T: 'a` for some type `T`. We can
  // often elaborate this. For example, if we know that
  // `[U]: 'a`, that implies that `U: 'a`. Similarly, if
@@ -385,15 +357,25 @@ impl<'tcx, O: Elaboratable<'tcx>> Elaborator<'tcx, O> {
  }
  })
  .map(|clause| {
- elaboratable.child(bound_predicate.rebind(clause).to_predicate(tcx))
+ elaboratable.child(bound_clause.rebind(clause).to_predicate(tcx))
  }),
  );
  }
- ty::PredicateKind::Ambiguous => {}
- ty::PredicateKind::AliasRelate(..) => {
- // No
+ ty::ClauseKind::RegionOutlives(..) => {
+ // Nothing to elaborate from `'a: 'b`.
+ }
+ ty::ClauseKind::WellFormed(..) => {
+ // Currently, we do not elaborate WF predicates,
+ // although we easily could.
+ }
+ ty::ClauseKind::Projection(..) => {
+ // Nothing to elaborate in a projection predicate.
+ }
+ ty::ClauseKind::ConstEvaluatable(..) => {
+ // Currently, we do not elaborate const-evaluatable
+ // predicates.
  }
- ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..)) => {
+ ty::ClauseKind::ConstArgHasType(..) => {
  // Nothing to elaborate
  }
  }

compiler/rustc_middle/src/ty/context.rs

@@ -121,6 +121,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
  type RegionOutlivesPredicate = ty::RegionOutlivesPredicate<'tcx>;
  type TypeOutlivesPredicate = ty::TypeOutlivesPredicate<'tcx>;
  type ProjectionPredicate = ty::ProjectionPredicate<'tcx>;
+ type NormalizesTo = ty::NormalizesTo<'tcx>;
  type SubtypePredicate = ty::SubtypePredicate<'tcx>;
  type CoercePredicate = ty::CoercePredicate<'tcx>;
  type ClosureKind = ty::ClosureKind;

compiler/rustc_middle/src/ty/flags.rs

@@ -272,6 +272,10 @@ impl FlagComputation {
  self.add_const(found);
  }
  ty::PredicateKind::Ambiguous => {}
+ ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term }) => {
+ self.add_alias_ty(alias);
+ self.add_term(term);
+ }
  ty::PredicateKind::AliasRelate(t1, t2, _) => {
  self.add_term(t1);
  self.add_term(t2);

compiler/rustc_middle/src/ty/mod.rs

@@ -553,6 +553,10 @@ impl<'tcx> Predicate<'tcx> {
  pub fn allow_normalization(self) -> bool {
  match self.kind().skip_binder() {
  PredicateKind::Clause(ClauseKind::WellFormed(_)) => false,
+ // `NormalizesTo` is only used in the new solver, so this shouldn't
+ // matter. Normalizing `term` would be 'wrong' however, as it changes whether
+ // `normalizes-to(<T as Trait>::Assoc, <T as Trait>::Assoc)` holds.
+ PredicateKind::NormalizesTo(..) => false,
  PredicateKind::Clause(ClauseKind::Trait(_))
  | PredicateKind::Clause(ClauseKind::RegionOutlives(_))
  | PredicateKind::Clause(ClauseKind::TypeOutlives(_))
@@ -1093,6 +1097,33 @@ impl<'tcx> PolyProjectionPredicate<'tcx> {
  }
 }
 
+/// Used by the new solver. Unlike a `ProjectionPredicate` this can only be
+/// proven by actually normalizing `alias`.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
+#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
+pub struct NormalizesTo<'tcx> {
+ pub alias: AliasTy<'tcx>,
+ pub term: Term<'tcx>,
+}
+
+impl<'tcx> NormalizesTo<'tcx> {
+ pub fn self_ty(self) -> Ty<'tcx> {
+ self.alias.self_ty()
+ }
+
+ pub fn with_self_ty(self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> NormalizesTo<'tcx> {
+ Self { alias: self.alias.with_self_ty(tcx, self_ty), ..self }
+ }
+
+ pub fn trait_def_id(self, tcx: TyCtxt<'tcx>) -> DefId {
+ self.alias.trait_def_id(tcx)
+ }
+
+ pub fn def_id(self) -> DefId {
+ self.alias.def_id
+ }
+}
+
 pub trait ToPolyTraitRef<'tcx> {
  fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx>;
 }
@@ -1274,13 +1305,20 @@ impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyProjectionPredicate<'tcx> {
  }
 }
 
+impl<'tcx> ToPredicate<'tcx> for NormalizesTo<'tcx> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ PredicateKind::NormalizesTo(self).to_predicate(tcx)
+ }
+}
+
 impl<'tcx> Predicate<'tcx> {
  pub fn to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>> {
  let predicate = self.kind();
  match predicate.skip_binder() {
  PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
  PredicateKind::Clause(ClauseKind::Projection(..))
  | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+ | PredicateKind::NormalizesTo(..)
  | PredicateKind::AliasRelate(..)
  | PredicateKind::Subtype(..)
  | PredicateKind::Coerce(..)
@@ -1300,6 +1338,7 @@ impl<'tcx> Predicate<'tcx> {
  PredicateKind::Clause(ClauseKind::Projection(t)) => Some(predicate.rebind(t)),
  PredicateKind::Clause(ClauseKind::Trait(..))
  | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+ | PredicateKind::NormalizesTo(..)
  | PredicateKind::AliasRelate(..)
  | PredicateKind::Subtype(..)
  | PredicateKind::Coerce(..)

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2814,6 +2814,7 @@ define_print! {
  p!("the constant `", print(c1), "` equals `", print(c2), "`")
  }
  ty::PredicateKind::Ambiguous => p!("ambiguous"),
+ ty::PredicateKind::NormalizesTo(data) => p!(print(data.alias), " normalizes-to ", print(data.term)),
  ty::PredicateKind::AliasRelate(t1, t2, dir) => p!(print(t1), write(" {} ", dir), print(t2)),
  }
  }

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -173,6 +173,12 @@ impl<'tcx> fmt::Debug for ty::ProjectionPredicate<'tcx> {
  }
 }
 
+impl<'tcx> fmt::Debug for ty::NormalizesTo<'tcx> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "NormalizesTo({:?}, {:?})", self.alias, self.term)
+ }
+}
+
 impl<'tcx> fmt::Debug for ty::Predicate<'tcx> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  write!(f, "{:?}", self.kind())

compiler/rustc_smir/src/rustc_smir/convert/ty.rs

@@ -601,6 +601,7 @@ impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> {
  stable_mir::ty::PredicateKind::ConstEquate(a.stable(tables), b.stable(tables))
  }
  PredicateKind::Ambiguous => stable_mir::ty::PredicateKind::Ambiguous,
+ PredicateKind::NormalizesTo(_pred) => unimplemented!(),
  PredicateKind::AliasRelate(a, b, alias_relation_direction) => {
  stable_mir::ty::PredicateKind::AliasRelate(
  a.unpack().stable(tables),

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

@@ -423,6 +423,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
  ty::PredicateKind::ConstEquate(_, _) => {
  bug!("ConstEquate should not be emitted when `-Ztrait-solver=next` is active")
  }
+ ty::PredicateKind::NormalizesTo(_) => unimplemented!(),
  ty::PredicateKind::AliasRelate(lhs, rhs, direction) => self
  .compute_alias_relate_goal(Goal {
  param_env,

compiler/rustc_trait_selection/src/solve/fulfill.rs

@@ -108,6 +108,11 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
  MismatchedProjectionTypes { err: TypeError::Mismatch },
  )
  }
+ ty::PredicateKind::NormalizesTo(..) => {
+ FulfillmentErrorCode::CodeProjectionError(
+ MismatchedProjectionTypes { err: TypeError::Mismatch },
+ )
+ }
  ty::PredicateKind::AliasRelate(_, _, _) => {
  FulfillmentErrorCode::CodeProjectionError(
  MismatchedProjectionTypes { err: TypeError::Mismatch },