Add Alias to smir

compiler/rustc_smir/src/rustc_internal/mod.rs

@@ -47,6 +47,10 @@ pub fn generator_def(did: DefId) -> stable_mir::ty::GeneratorDef {
     with_tables(|t| t.generator_def(did))
 }
 
+pub fn alias_def(did: DefId) -> stable_mir::ty::AliasDef {
+    with_tables(|t| t.alias_def(did))
+}
+
 pub fn param_def(did: DefId) -> stable_mir::ty::ParamDef {
     with_tables(|t| t.param_def(did))
 }
@@ -84,6 +88,10 @@ impl<'tcx> Tables<'tcx> {
         stable_mir::ty::GeneratorDef(self.create_def_id(did))
     }
 
+    pub fn alias_def(&mut self, did: DefId) -> stable_mir::ty::AliasDef {
+        stable_mir::ty::AliasDef(self.create_def_id(did))
+    }
+
     pub fn param_def(&mut self, did: DefId) -> stable_mir::ty::ParamDef {
         stable_mir::ty::ParamDef(self.create_def_id(did))
     }

compiler/rustc_smir/src/rustc_smir/mod.rs

@@ -237,6 +237,27 @@ impl<'tcx> Stable<'tcx> for mir::CastKind {
     }
 }
 
+impl<'tcx> Stable<'tcx> for ty::AliasKind {
+    type T = stable_mir::ty::AliasKind;
+    fn stable(&self, _: &mut Tables<'tcx>) -> Self::T {
+        use ty::AliasKind::*;
+        match self {
+            Projection => stable_mir::ty::AliasKind::Projection,
+            Inherent => stable_mir::ty::AliasKind::Inherent,
+            Opaque => stable_mir::ty::AliasKind::Opaque,
+            Weak => stable_mir::ty::AliasKind::Weak,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> {
+    type T = stable_mir::ty::AliasTy;
+    fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T {
+        let ty::AliasTy { args, def_id, .. } = self;
+        stable_mir::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables) }
+    }
+}
+
 impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion {
     type T = stable_mir::mir::PointerCoercion;
     fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T {
@@ -667,7 +688,9 @@ impl<'tcx> Stable<'tcx> for Ty<'tcx> {
             ty::Tuple(fields) => TyKind::RigidTy(RigidTy::Tuple(
                 fields.iter().map(|ty| tables.intern_ty(ty)).collect(),
             )),
-            ty::Alias(_, _) => todo!(),
+            ty::Alias(alias_kind, alias_ty) => {
+                TyKind::Alias(alias_kind.stable(tables), alias_ty.stable(tables))
+            }
             ty::Param(_) => todo!(),
             ty::Bound(_, _) => todo!(),
             ty::Placeholder(..)

compiler/rustc_smir/src/stable_mir/ty.rs

@@ -17,6 +17,7 @@ type Span = Opaque;
 #[derive(Clone, Debug)]
 pub enum TyKind {
     RigidTy(RigidTy),
+    Alias(AliasKind, AliasTy),
 }
 
 #[derive(Clone, Debug)]
@@ -94,6 +95,9 @@ pub struct BrNamedDef(pub(crate) DefId);
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct AdtDef(pub(crate) DefId);
 
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct AliasDef(pub(crate) DefId);
+
 #[derive(Clone, Debug)]
 pub struct GenericArgs(pub Vec<GenericArgKind>);
 
@@ -104,6 +108,20 @@ pub enum GenericArgKind {
     Const(Const),
 }
 
+#[derive(Clone, Debug)]
+pub enum AliasKind {
+    Projection,
+    Inherent,
+    Opaque,
+    Weak,
+}
+
+#[derive(Clone, Debug)]
+pub struct AliasTy {
+    pub def_id: AliasDef,
+    pub args: GenericArgs,
+}
+
 pub type PolyFnSig = Binder<FnSig>;
 
 #[derive(Clone, Debug)]

compiler/rustc_type_ir/src/sty.rs

@@ -39,6 +39,7 @@ pub enum AliasKind {
     /// A projection `<Type as Trait>::AssocType`.
     /// Can get normalized away if monomorphic enough.
     Projection,
+    /// An associated type in an inherent `impl`
     Inherent,
     /// An opaque type (usually from `impl Trait` in type aliases or function return types)
     /// Can only be normalized away in RevealAll mode