introduce Unnormalized wrapper and make instantiation use it

Author: adwinwhite

compiler/rustc_middle/src/ty/generics.rs

@@ -5,7 +5,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::{Span, Symbol, kw};
 use tracing::instrument;
 
-use super::{Clause, InstantiatedPredicates, ParamConst, ParamTy, Ty, TyCtxt};
+use super::{Clause, InstantiatedPredicates, ParamConst, ParamTy, Ty, TyCtxt, Unnormalized};
 use crate::ty;
 use crate::ty::{EarlyBinder, GenericArgsRef};
 
@@ -368,23 +368,25 @@ impl<'tcx> GenericPredicates<'tcx> {
         self,
         tcx: TyCtxt<'tcx>,
         args: GenericArgsRef<'tcx>,
-    ) -> InstantiatedPredicates<'tcx> {
+    ) -> Unnormalized<InstantiatedPredicates<'tcx>> {
         let mut instantiated = InstantiatedPredicates::empty();
         self.instantiate_into(tcx, &mut instantiated, args);
-        instantiated
+        Unnormalized::new(instantiated)
     }
 
     pub fn instantiate_own(
         self,
         tcx: TyCtxt<'tcx>,
         args: GenericArgsRef<'tcx>,
-    ) -> impl Iterator<Item = (Clause<'tcx>, Span)> + DoubleEndedIterator + ExactSizeIterator {
+    ) -> impl Iterator<Item = Unnormalized<(Clause<'tcx>, Span)>> + DoubleEndedIterator + ExactSizeIterator
+    {
         EarlyBinder::bind(self.predicates).iter_instantiated_copied(tcx, args)
     }
 
     pub fn instantiate_own_identity(
         self,
-    ) -> impl Iterator<Item = (Clause<'tcx>, Span)> + DoubleEndedIterator + ExactSizeIterator {
+    ) -> impl Iterator<Item = Unnormalized<(Clause<'tcx>, Span)>> + DoubleEndedIterator + ExactSizeIterator
+    {
         EarlyBinder::bind(self.predicates).iter_identity_copied()
     }
 
@@ -399,15 +401,20 @@ impl<'tcx> GenericPredicates<'tcx> {
             tcx.predicates_of(def_id).instantiate_into(tcx, instantiated, args);
         }
         instantiated.predicates.extend(
-            self.predicates.iter().map(|(p, _)| EarlyBinder::bind(*p).instantiate(tcx, args)),
+            self.predicates
+                .iter()
+                .map(|(p, _)| EarlyBinder::bind(*p).instantiate(tcx, args).skip_normalization()),
         );
         instantiated.spans.extend(self.predicates.iter().map(|(_, sp)| *sp));
     }
 
-    pub fn instantiate_identity(self, tcx: TyCtxt<'tcx>) -> InstantiatedPredicates<'tcx> {
+    pub fn instantiate_identity(
+        self,
+        tcx: TyCtxt<'tcx>,
+    ) -> Unnormalized<InstantiatedPredicates<'tcx>> {
         let mut instantiated = InstantiatedPredicates::empty();
         self.instantiate_identity_into(tcx, &mut instantiated);
-        instantiated
+        Unnormalized::new(instantiated)
     }
 
     fn instantiate_identity_into(
@@ -438,25 +445,27 @@ impl<'tcx> ConstConditions<'tcx> {
         self,
         tcx: TyCtxt<'tcx>,
         args: GenericArgsRef<'tcx>,
-    ) -> Vec<(ty::PolyTraitRef<'tcx>, Span)> {
+    ) -> Unnormalized<Vec<(ty::PolyTraitRef<'tcx>, Span)>> {
         let mut instantiated = vec![];
         self.instantiate_into(tcx, &mut instantiated, args);
-        instantiated
+        Unnormalized::new(instantiated)
     }
 
     pub fn instantiate_own(
         self,
         tcx: TyCtxt<'tcx>,
         args: GenericArgsRef<'tcx>,
-    ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, Span)> + DoubleEndedIterator + ExactSizeIterator
-    {
+    ) -> impl Iterator<Item = Unnormalized<(ty::PolyTraitRef<'tcx>, Span)>>
+    + DoubleEndedIterator
+    + ExactSizeIterator {
         EarlyBinder::bind(self.predicates).iter_instantiated_copied(tcx, args)
     }
 
     pub fn instantiate_own_identity(
         self,
-    ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, Span)> + DoubleEndedIterator + ExactSizeIterator
-    {
+    ) -> impl Iterator<Item = Unnormalized<(ty::PolyTraitRef<'tcx>, Span)>>
+    + DoubleEndedIterator
+    + ExactSizeIterator {
         EarlyBinder::bind(self.predicates).iter_identity_copied()
     }
 
@@ -471,14 +480,19 @@ impl<'tcx> ConstConditions<'tcx> {
             tcx.const_conditions(def_id).instantiate_into(tcx, instantiated, args);
         }
         instantiated.extend(
-            self.predicates.iter().map(|&(p, s)| (EarlyBinder::bind(p).instantiate(tcx, args), s)),
+            self.predicates.iter().map(|&(p, s)| {
+                (EarlyBinder::bind(p).instantiate(tcx, args).skip_normalization(), s)
+            }),
         );
     }
 
-    pub fn instantiate_identity(self, tcx: TyCtxt<'tcx>) -> Vec<(ty::PolyTraitRef<'tcx>, Span)> {
+    pub fn instantiate_identity(
+        self,
+        tcx: TyCtxt<'tcx>,
+    ) -> Unnormalized<Vec<(ty::PolyTraitRef<'tcx>, Span)>> {
         let mut instantiated = vec![];
         self.instantiate_identity_into(tcx, &mut instantiated);
-        instantiated
+        Unnormalized::new(instantiated)
     }
 
     fn instantiate_identity_into(

compiler/rustc_type_ir/src/binder.rs

@@ -16,7 +16,7 @@ use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldabl
 use crate::inherent::*;
 use crate::lift::Lift;
 use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
-use crate::{self as ty, DebruijnIndex, Interner, UniverseIndex};
+use crate::{self as ty, DebruijnIndex, Interner, UniverseIndex, Unnormalized};
 
 /// `Binder` is a binder for higher-ranked lifetimes or types. It is part of the
 /// compiler's representation for things like `for<'a> Fn(&'a isize)`
@@ -459,8 +459,8 @@ where
 
     /// Similar to [`instantiate_identity`](EarlyBinder::instantiate_identity),
     /// but on an iterator of `TypeFoldable` values.
-    pub fn iter_identity(self) -> Iter::IntoIter {
-        self.value.into_iter()
+    pub fn iter_identity(self) -> impl Iterator<Item = Unnormalized<Iter::Item>> {
+        self.value.into_iter().map(Unnormalized::new)
     }
 }
 
@@ -475,7 +475,7 @@ where
     Iter::Item: TypeFoldable<I>,
     A: SliceLike<Item = I::GenericArg>,
 {
-    type Item = Iter::Item;
+    type Item = Unnormalized<Iter::Item>;
 
     fn next(&mut self) -> Option<Self::Item> {
         Some(
@@ -526,8 +526,8 @@ where
 
     /// Similar to [`instantiate_identity`](EarlyBinder::instantiate_identity),
     /// but on an iterator of values that deref to a `TypeFoldable`.
-    pub fn iter_identity_copied(self) -> IterIdentityCopied<Iter> {
-        IterIdentityCopied { it: self.value.into_iter() }
+    pub fn iter_identity_copied(self) -> IterIdentityCopied<I, Iter> {
+        IterIdentityCopied { it: self.value.into_iter(), _tcx: PhantomData }
     }
 }
 
@@ -542,7 +542,7 @@ where
     Iter::Item: Deref,
     <Iter::Item as Deref>::Target: Copy + TypeFoldable<I>,
 {
-    type Item = <Iter::Item as Deref>::Target;
+    type Item = Unnormalized<<Iter::Item as Deref>::Target>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.it.next().map(|value| {
@@ -576,38 +576,39 @@ where
 {
 }
 
-pub struct IterIdentityCopied<Iter: IntoIterator> {
+pub struct IterIdentityCopied<I: Interner, Iter: IntoIterator> {
     it: Iter::IntoIter,
+    _tcx: PhantomData<fn() -> I>,
 }
 
-impl<Iter: IntoIterator> Iterator for IterIdentityCopied<Iter>
+impl<I: Interner, Iter: IntoIterator> Iterator for IterIdentityCopied<I, Iter>
 where
     Iter::Item: Deref,
     <Iter::Item as Deref>::Target: Copy,
 {
-    type Item = <Iter::Item as Deref>::Target;
+    type Item = Unnormalized<<Iter::Item as Deref>::Target>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.it.next().map(|i| *i)
+        self.it.next().map(|i| Unnormalized::new(*i))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.it.size_hint()
     }
 }
 
-impl<Iter: IntoIterator> DoubleEndedIterator for IterIdentityCopied<Iter>
+impl<I: Interner, Iter: IntoIterator> DoubleEndedIterator for IterIdentityCopied<I, Iter>
 where
     Iter::IntoIter: DoubleEndedIterator,
     Iter::Item: Deref,
     <Iter::Item as Deref>::Target: Copy,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
-        self.it.next_back().map(|i| *i)
+        self.it.next_back().map(|i| Unnormalized::new(*i))
     }
 }
 
-impl<Iter: IntoIterator> ExactSizeIterator for IterIdentityCopied<Iter>
+impl<I: Interner, Iter: IntoIterator> ExactSizeIterator for IterIdentityCopied<I, Iter>
 where
     Iter::IntoIter: ExactSizeIterator,
     Iter::Item: Deref,
@@ -638,7 +639,7 @@ impl<I: Interner, T: Iterator> Iterator for EarlyBinderIter<I, T> {
 }
 
 impl<I: Interner, T: TypeFoldable<I>> ty::EarlyBinder<I, T> {
-    pub fn instantiate<A>(self, cx: I, args: A) -> T
+    pub fn instantiate<A>(self, cx: I, args: A) -> Unnormalized<T>
     where
         A: SliceLike<Item = I::GenericArg>,
     {
@@ -651,10 +652,10 @@ impl<I: Interner, T: TypeFoldable<I>> ty::EarlyBinder<I, T> {
                 "{:?} has parameters, but no args were provided in instantiate",
                 self.value,
             );
-            return self.value;
+            return Unnormalized::new(self.value);
         }
         let mut folder = ArgFolder { cx, args: args.as_slice(), binders_passed: 0 };
-        self.value.fold_with(&mut folder)
+        Unnormalized::new(self.value.fold_with(&mut folder))
     }
 
     /// Makes the identity replacement `T0 => T0, ..., TN => TN`.
@@ -665,8 +666,8 @@ impl<I: Interner, T: TypeFoldable<I>> ty::EarlyBinder<I, T> {
     /// - Outside of `foo`, `T` is bound (represented by the presence of `EarlyBinder`).
     /// - Inside of the body of `foo`, we treat `T` as a placeholder by calling
     /// `instantiate_identity` to discharge the `EarlyBinder`.
-    pub fn instantiate_identity(self) -> T {
-        self.value
+    pub fn instantiate_identity(self) -> Unnormalized<T> {
+        Unnormalized::new(self.value)
     }
 
     /// Returns the inner value, but only if it contains no bound vars.

compiler/rustc_type_ir/src/lib.rs

@@ -53,6 +53,7 @@ mod predicate_kind;
 mod region_kind;
 mod ty_info;
 mod ty_kind;
+mod unnormalized;
 mod upcast;
 mod visit;
 
@@ -80,6 +81,7 @@ pub use rustc_ast_ir::{FloatTy, IntTy, Movability, Mutability, Pinnedness, UintT
 use rustc_type_ir_macros::GenericTypeVisitable;
 pub use ty_info::*;
 pub use ty_kind::*;
+pub use unnormalized::Unnormalized;
 pub use upcast::*;
 pub use visit::*;
 

compiler/rustc_type_ir/src/unnormalized.rs

@@ -0,0 +1,18 @@
+/// A wrapper for value that needs normalization.
+/// FIXME: This is very WIP. It's planned to replace the `skip_normalization` spreaded
+/// in the codebase with proper normalization. It's the first step toward switching to eager
+/// normalization with the next solver.
+#[derive(Clone, PartialOrd, PartialEq, Debug)]
+pub struct Unnormalized<T> {
+    value: T,
+}
+
+impl<T> Unnormalized<T> {
+    pub fn new(value: T) -> Unnormalized<T> {
+        Unnormalized { value }
+    }
+
+    pub fn skip_normalization(self) -> T {
+        self.value
+    }
+}