Refactor AliasTy & AliasTerm to use Alias

compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs

@@ -13,10 +13,16 @@ where
     #[instrument(level = "trace", skip(self), ret)]
     pub(super) fn normalize_anon_const(
         &mut self,
-        goal: Goal<I, ty::NormalizesTo<I>>,
-        def_id: I::UnevaluatedConstId,
+        goal: Goal<I, ty::NormalizesTo<I, I::UnevaluatedConstId>>,
     ) -> QueryResultOrRerunNonErased<I> {
-        let uv = goal.predicate.alias.expect_ct();
+        let cx = self.cx();
+        let uv = ty::UnevaluatedConst::new(
+            cx,
+            ty::UnevaluatedConstKind::Anon { def_id: goal.predicate.alias.kind },
+            goal.predicate.alias.args,
+        );
+        let alias = ty::AliasTerm::from(uv);
+        let goal = goal.with(cx, ty::NormalizesTo { alias, term: goal.predicate.term });
         self.evaluate_const_and_instantiate_normalizes_to_term(goal, uv)
     }
 }

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -11,7 +11,7 @@ use rustc_type_ir::solve::{
     RerunNonErased, RerunReason, RerunResultExt,
 };
 use rustc_type_ir::{
-    self as ty, FieldInfo, Interner, NormalizesTo, PredicateKind, Unnormalized, Upcast as _,
+    self as ty, Alias, FieldInfo, Interner, NormalizesTo, PredicateKind, Unnormalized, Upcast as _,
 };
 use tracing::instrument;
 
@@ -50,7 +50,13 @@ where
                 self.normalize_free_alias(goal).map_err(Into::into)
             }
             ty::AliasTermKind::AnonConst { def_id } => {
-                self.normalize_anon_const(goal, def_id).map_err(Into::into)
+                let cx = self.cx();
+                let alias =
+                    Alias::new_unevaluated_const_from_args(cx, def_id, goal.predicate.alias.args);
+                self.normalize_anon_const(
+                    goal.with(cx, ty::NormalizesTo { alias, term: goal.predicate.term }),
+                )
+                .map_err(Into::into)
             }
         }
     }
@@ -121,9 +127,9 @@ where
     /// We know `term` to always be a fully unconstrained inference variable, so
     /// `eq` should never fail here. However, in case `term` contains aliases, we
     /// emit nested `AliasRelate` goals to structurally normalize the alias.
-    pub fn instantiate_normalizes_to_term(
+    pub fn instantiate_normalizes_to_term<K>(
         &mut self,
-        goal: Goal<I, NormalizesTo<I>>,
+        goal: Goal<I, NormalizesTo<I, K>>,
         term: I::Term,
     ) {
         self.eq(goal.param_env, goal.predicate.term, term)
@@ -132,9 +138,9 @@ where
 
     /// Unlike `instantiate_normalizes_to_term` this instantiates the expected term
     /// with a rigid alias. Using this is pretty much always wrong.
-    pub fn structurally_instantiate_normalizes_to_term(
+    pub fn structurally_instantiate_normalizes_to_term<K>(
         &mut self,
-        goal: Goal<I, NormalizesTo<I>>,
+        goal: Goal<I, NormalizesTo<I, K>>,
         term: ty::AliasTerm<I>,
     ) {
         self.relate_rigid_alias_non_alias(goal.param_env, term, ty::Invariant, goal.predicate.term)

compiler/rustc_type_ir/src/lib.rs

@@ -52,6 +52,7 @@ mod pattern;
 mod predicate;
 mod predicate_kind;
 mod region_kind;
+mod ty;
 mod ty_info;
 mod ty_kind;
 mod unnormalized;
@@ -80,6 +81,7 @@ pub use predicate_kind::*;
 pub use region_kind::*;
 pub use rustc_ast_ir::{FloatTy, IntTy, Movability, Mutability, Pinnedness, UintTy};
 use rustc_type_ir_macros::GenericTypeVisitable;
+pub use ty::{Alias, AliasTerm, AliasTy};
 pub use ty_info::*;
 pub use ty_kind::*;
 pub use unnormalized::Unnormalized;

compiler/rustc_type_ir/src/predicate.rs

@@ -8,10 +8,12 @@ use rustc_type_ir_macros::{
     GenericTypeVisitable, Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic,
 };
 
+use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder};
 use crate::inherent::*;
+use crate::ty::AliasTerm;
 use crate::upcast::{Upcast, UpcastFrom};
-use crate::visit::TypeVisitableExt as _;
-use crate::{self as ty, AliasTyKind, Interner, UnevaluatedConstKind};
+use crate::visit::{TypeVisitable, TypeVisitableExt as _, TypeVisitor};
+use crate::{self as ty, Alias, AliasTyKind, Interner, UnevaluatedConstKind, try_visit};
 
 /// `A: 'region`
 #[derive_where(Clone, Hash, PartialEq, Debug; I: Interner, A)]
@@ -544,7 +546,7 @@ impl<I: Interner> ty::Binder<I, ExistentialProjection<I>> {
 }
 
 #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
-#[derive(Lift_Generic, GenericTypeVisitable)]
+#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic, GenericTypeVisitable)]
 #[cfg_attr(
     feature = "nightly",
     derive(Encodable_NoContext, Decodable_NoContext, StableHash_NoContext)
@@ -661,49 +663,14 @@ impl<I: Interner> From<ty::UnevaluatedConstKind<I>> for AliasTermKind<I> {
     }
 }
 
-/// Represents the unprojected term of a projection goal.
-///
-/// * For a projection, this would be `<Ty as Trait<...>>::N<...>`.
-/// * For an inherent projection, this would be `Ty::N<...>`.
-/// * For an opaque type, there is no explicit syntax.
-#[derive_where(Clone, Copy, Hash, PartialEq, Debug; I: Interner)]
-#[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic, Lift_Generic)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Decodable_NoContext, Encodable_NoContext, StableHash_NoContext)
-)]
-pub struct AliasTerm<I: Interner> {
-    /// The parameters of the associated or opaque item.
-    ///
-    /// For a projection, these are the generic parameters for the trait and the
-    /// GAT parameters, if there are any.
-    ///
-    /// For an inherent projection, they consist of the self type and the GAT parameters,
-    /// if there are any.
-    ///
-    /// For RPIT the generic parameters are for the generics of the function,
-    /// while for TAIT it is used for the generic parameters of the alias.
-    pub args: I::GenericArgs,
-
-    #[type_foldable(identity)]
-    #[type_visitable(ignore)]
-    pub kind: AliasTermKind<I>,
-
-    /// This field exists to prevent the creation of `AliasTerm` without using [`AliasTerm::new_from_args`].
-    #[derive_where(skip(Debug))]
-    _use_alias_term_new_instead: (),
-}
-
-impl<I: Interner> Eq for AliasTerm<I> {}
-
 impl<I: Interner> AliasTerm<I> {
     pub fn new_from_args(
         interner: I,
         kind: AliasTermKind<I>,
         args: I::GenericArgs,
     ) -> AliasTerm<I> {
         interner.debug_assert_args_compatible(kind.def_id(), args);
-        AliasTerm { kind, args, _use_alias_term_new_instead: () }
+        AliasTerm { kind, args, _use_alias_new_instead: () }
     }
 
     pub fn new(
@@ -733,7 +700,7 @@ impl<I: Interner> AliasTerm<I> {
                 panic!("Cannot turn `{}` into `AliasTy`", kind.descr())
             }
         };
-        ty::AliasTy { kind, args: self.args, _use_alias_ty_new_instead: () }
+        ty::AliasTy { kind, args: self.args, _use_alias_new_instead: () }
     }
 
     pub fn expect_ct(self) -> ty::UnevaluatedConst<I> {
@@ -884,21 +851,13 @@ impl<I: Interner> AliasTerm<I> {
 
 impl<I: Interner> From<ty::AliasTy<I>> for AliasTerm<I> {
     fn from(ty: ty::AliasTy<I>) -> Self {
-        AliasTerm {
-            args: ty.args,
-            kind: AliasTermKind::from(ty.kind),
-            _use_alias_term_new_instead: (),
-        }
+        AliasTerm { args: ty.args, kind: AliasTermKind::from(ty.kind), _use_alias_new_instead: () }
     }
 }
 
 impl<I: Interner> From<ty::UnevaluatedConst<I>> for AliasTerm<I> {
     fn from(ty: ty::UnevaluatedConst<I>) -> Self {
-        AliasTerm {
-            args: ty.args,
-            kind: AliasTermKind::from(ty.kind),
-            _use_alias_term_new_instead: (),
-        }
+        AliasTerm { args: ty.args, kind: AliasTermKind::from(ty.kind), _use_alias_new_instead: () }
     }
 }
 
@@ -977,18 +936,36 @@ impl<I: Interner> fmt::Debug for ProjectionPredicate<I> {
 
 /// Used by the new solver to normalize an alias. This always expects the `term` to
 /// be an unconstrained inference variable which is used as the output.
-#[derive_where(Clone, Copy, Hash, PartialEq; I: Interner)]
-#[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic, Lift_Generic)]
+#[derive_where(Clone, Copy, Hash, Eq, PartialEq; I: Interner, K)]
+#[derive(GenericTypeVisitable, Lift_Generic)]
 #[cfg_attr(
     feature = "nightly",
     derive(Decodable_NoContext, Encodable_NoContext, StableHash_NoContext)
 )]
-pub struct NormalizesTo<I: Interner> {
-    pub alias: AliasTerm<I>,
+pub struct NormalizesTo<I: Interner, K = AliasTermKind<I>> {
+    pub alias: Alias<I, K>,
     pub term: I::Term,
 }
 
-impl<I: Interner> Eq for NormalizesTo<I> {}
+impl<I: Interner, K: TypeVisitable<I>> TypeVisitable<I> for NormalizesTo<I, K> {
+    fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
+        try_visit!(self.alias.visit_with(visitor));
+        self.term.visit_with(visitor)
+    }
+}
+
+impl<I: Interner, K: TypeFoldable<I>> TypeFoldable<I> for NormalizesTo<I, K> {
+    fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(NormalizesTo {
+            alias: self.alias.try_fold_with(folder)?,
+            term: self.term.try_fold_with(folder)?,
+        })
+    }
+
+    fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self {
+        NormalizesTo { alias: self.alias.fold_with(folder), term: self.term.fold_with(folder) }
+    }
+}
 
 impl<I: Interner> NormalizesTo<I> {
     pub fn self_ty(self) -> I::Ty {
@@ -1008,7 +985,7 @@ impl<I: Interner> NormalizesTo<I> {
     }
 }
 
-impl<I: Interner> fmt::Debug for NormalizesTo<I> {
+impl<I: Interner, K: fmt::Debug> fmt::Debug for NormalizesTo<I, K> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "NormalizesTo({:?}, {:?})", self.alias, self.term)
     }

compiler/rustc_type_ir/src/ty/alias.rs

@@ -0,0 +1,66 @@
+use derive_where::derive_where;
+#[cfg(feature = "nightly")]
+use rustc_macros::{Decodable_NoContext, Encodable_NoContext, StableHash_NoContext};
+use rustc_type_ir_macros::{
+    GenericTypeVisitable, Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic,
+};
+
+use crate::Interner;
+use crate::predicate::AliasTermKind;
+use crate::ty_kind::AliasTyKind;
+
+/// Represents an alias of a type, constant, or other term-like item.
+///
+/// * For a projection, this would be `<Ty as Trait<...>>::N<...>`.
+/// * For an inherent projection, this would be `Ty::N<...>`.
+/// * For an opaque type, there is no explicit syntax.
+#[derive_where(Clone, Copy, Hash, PartialEq, Debug; I: Interner, K)]
+#[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic, Lift_Generic)]
+#[cfg_attr(
+    feature = "nightly",
+    derive(Decodable_NoContext, Encodable_NoContext, StableHash_NoContext)
+)]
+pub struct Alias<I: Interner, K> {
+    /// The parameters of the associated, opaque, or constant alias.
+    ///
+    /// For a projection, these are the generic parameters for the trait and the
+    /// GAT parameters, if there are any.
+    ///
+    /// For an inherent projection, they consist of the self type and the GAT parameters,
+    /// if there are any.
+    ///
+    /// For RPIT the generic parameters are for the generics of the function,
+    /// while for TAIT it is used for the generic parameters of the alias.
+    pub args: I::GenericArgs,
+
+    pub kind: K,
+
+    /// This field exists to prevent the creation of `Alias` without using the relevant constructor.
+    #[derive_where(skip(Debug))]
+    #[type_visitable(ignore)]
+    #[type_foldable(identity)]
+    #[lift(identity)]
+    pub(crate) _use_alias_new_instead: (),
+}
+
+impl<I: Interner, K: PartialEq> Eq for Alias<I, K> {}
+
+impl<I: Interner, K: Copy> Alias<I, K> {
+    pub fn kind(self, _interner: I) -> K {
+        self.kind
+    }
+}
+
+impl<I: Interner> Alias<I, I::UnevaluatedConstId> {
+    pub fn new_unevaluated_const_from_args(
+        interner: I,
+        kind: I::UnevaluatedConstId,
+        args: I::GenericArgs,
+    ) -> Self {
+        interner.debug_assert_args_compatible(kind.into(), args);
+        Alias { kind, args, _use_alias_new_instead: () }
+    }
+}
+
+pub type AliasTerm<I> = Alias<I, AliasTermKind<I>>;
+pub type AliasTy<I> = Alias<I, AliasTyKind<I>>;

compiler/rustc_type_ir/src/ty/mod.rs

@@ -0,0 +1,3 @@
+mod alias;
+
+pub use alias::{Alias, AliasTerm, AliasTy};

compiler/rustc_type_ir/src/ty_kind.rs

@@ -17,14 +17,15 @@ use rustc_type_ir_macros::{
 use self::TyKind::*;
 pub use self::closure::*;
 use crate::inherent::*;
+use crate::ty::AliasTy;
 #[cfg(feature = "nightly")]
 use crate::visit::TypeVisitable;
 use crate::{self as ty, BoundVarIndexKind, FloatTy, IntTy, Interner, UintTy};
 
 mod closure;
 
 #[derive_where(Clone, Copy, Hash, PartialEq, Debug; I: Interner)]
-#[derive(GenericTypeVisitable, Lift_Generic)]
+#[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic, Lift_Generic)]
 #[cfg_attr(
     feature = "nightly",
     derive(Encodable_NoContext, Decodable_NoContext, StableHash_NoContext)
@@ -431,45 +432,10 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
     }
 }
 
-/// Represents the projection of an associated, opaque, or lazy-type-alias type.
-///
-/// * For a projection, this would be `<Ty as Trait<...>>::N<...>`.
-/// * For an inherent projection, this would be `Ty::N<...>`.
-/// * For an opaque type, there is no explicit syntax.
-#[derive_where(Clone, Copy, Hash, PartialEq, Debug; I: Interner)]
-#[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic, Lift_Generic)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Decodable_NoContext, Encodable_NoContext, StableHash_NoContext)
-)]
-pub struct AliasTy<I: Interner> {
-    /// The parameters of the associated or opaque type.
-    ///
-    /// For a projection, these are the generic parameters for the trait and the
-    /// GAT parameters, if there are any.
-    ///
-    /// For an inherent projection, they consist of the self type and the GAT parameters,
-    /// if there are any.
-    ///
-    /// For RPIT the generic parameters are for the generics of the function,
-    /// while for TAIT it is used for the generic parameters of the alias.
-    pub args: I::GenericArgs,
-
-    #[type_foldable(identity)]
-    #[type_visitable(ignore)]
-    pub kind: AliasTyKind<I>,
-
-    /// This field exists to prevent the creation of `AliasTy` without using [`AliasTy::new_from_args`].
-    #[derive_where(skip(Debug))]
-    pub(crate) _use_alias_ty_new_instead: (),
-}
-
-impl<I: Interner> Eq for AliasTy<I> {}
-
 impl<I: Interner> AliasTy<I> {
     pub fn new_from_args(interner: I, kind: AliasTyKind<I>, args: I::GenericArgs) -> AliasTy<I> {
         interner.debug_assert_args_compatible(kind.def_id(), args);
-        AliasTy { kind, args, _use_alias_ty_new_instead: () }
+        AliasTy { kind, args, _use_alias_new_instead: () }
     }
 
     pub fn new(
@@ -481,6 +447,19 @@ impl<I: Interner> AliasTy<I> {
         Self::new_from_args(interner, kind, args)
     }
 
+    pub fn new_from_def_id(interner: I, def_id: I::DefId, args: I::GenericArgs) -> AliasTy<I> {
+        let kind = interner.alias_ty_kind_from_def_id(def_id);
+        Self::new_from_args(interner, kind, args)
+    }
+
+    pub fn def_id(self) -> I::DefId {
+        self.kind.def_id()
+    }
+
+    pub fn with_args(self, interner: I, args: I::GenericArgs) -> Self {
+        Self::new_from_args(interner, self.kind, args)
+    }
+
     /// Whether this alias type is an opaque.
     pub fn is_opaque(self) -> bool {
         matches!(self.kind, AliasTyKind::Opaque { .. })