Add TyKind::TyAlias support in rustc_middle

Author: GuillaumeGomez

compiler/rustc_middle/src/ty/context.rs

@@ -1726,6 +1726,16 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn local_visibility(self, def_id: LocalDefId) -> Visibility {
         self.visibility(def_id).expect_local()
     }
+
+    /// As long as the kind of `ty` is `TyAlias`, then it'll continue to peel it off and return
+    /// the type below it.
+    pub fn peel_off_ty_alias(self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
+        while let ty::TyAlias(def_id, substs) = *ty.kind() {
+            let binder_ty = self.bound_type_of(def_id);
+            ty = binder_ty.subst(self, substs);
+        }
+        ty
+    }
 }
 
 /// A trait implemented for all `X<'a>` types that can be safely and
@@ -1996,7 +2006,7 @@ pub mod tls {
 }
 
 macro_rules! sty_debug_print {
-    ($fmt: expr, $ctxt: expr, $($variant: ident),*) => {{
+    ($fmt: expr, $ctxt: expr, $($variant: ident),* $(,)?) => {{
         // Curious inner module to allow variant names to be used as
         // variable names.
         #[allow(non_snake_case)]
@@ -2095,7 +2105,8 @@ impl<'tcx> TyCtxt<'tcx> {
                     Infer,
                     Projection,
                     Opaque,
-                    Foreign
+                    Foreign,
+                    TyAlias,
                 )?;
 
                 writeln!(fmt, "InternalSubsts interner: #{}", self.0.interners.substs.len())?;
@@ -2633,6 +2644,11 @@ impl<'tcx> TyCtxt<'tcx> {
         self.mk_ty(Opaque(def_id, substs))
     }
 
+    #[inline]
+    pub fn mk_ty_alias(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
+        self.mk_ty(TyAlias(def_id, substs))
+    }
+
     pub fn mk_place_field(self, place: Place<'tcx>, f: Field, ty: Ty<'tcx>) -> Place<'tcx> {
         self.mk_place_elem(place, PlaceElem::Field(f, ty))
     }

compiler/rustc_middle/src/ty/error.rs

@@ -329,6 +329,7 @@ impl<'tcx> Ty<'tcx> {
             ty::Param(p) => format!("type parameter `{}`", p).into(),
             ty::Opaque(..) => "opaque type".into(),
             ty::Error(_) => "type error".into(),
+            ty::TyAlias(_, _) => "type alias".into(),
         }
     }
 
@@ -366,6 +367,7 @@ impl<'tcx> Ty<'tcx> {
             ty::Projection(_) => "associated type".into(),
             ty::Param(_) => "type parameter".into(),
             ty::Opaque(..) => "opaque type".into(),
+            ty::TyAlias(_, _) => "type alias".into(),
         }
     }
 }

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -127,6 +127,9 @@ pub fn simplify_type<'tcx>(
             TreatParams::AsPlaceholder => Some(PlaceholderSimplifiedType),
             TreatParams::AsInfer => None,
         },
+        // A `TyAlias` is never fully normalized as you can always normalize it further so returning
+        // `None` all the time.
+        ty::TyAlias(..) => None,
         ty::Projection(_) => match treat_params {
             // When treating `ty::Param` as a placeholder, projections also
             // don't unify with anything else as long as they are fully normalized.
@@ -229,7 +232,7 @@ impl DeepRejectCtxt {
         match impl_ty.kind() {
             // Start by checking whether the type in the impl may unify with
             // pretty much everything. Just return `true` in that case.
-            ty::Param(_) | ty::Projection(_) | ty::Error(_) => return true,
+            ty::Param(_) | ty::Projection(_) | ty::TyAlias(_, _) | ty::Error(_) => return true,
             // These types only unify with inference variables or their own
             // variant.
             ty::Bool
@@ -352,7 +355,7 @@ impl DeepRejectCtxt {
             // projections can unify with other stuff.
             //
             // Looking forward to lazy normalization this is the safer strategy anyways.
-            ty::Projection(_) => true,
+            ty::Projection(_) | ty::TyAlias(_, _) => true,
 
             ty::Error(_) => true,
 

compiler/rustc_middle/src/ty/flags.rs

@@ -155,6 +155,11 @@ impl FlagComputation {
                 self.add_substs(substs);
             }
 
+            &ty::TyAlias(_, substs) => {
+                self.add_flags(TypeFlags::HAS_TY_PROJECTION);
+                self.add_substs(substs);
+            }
+
             &ty::Projection(data) => {
                 self.add_flags(TypeFlags::HAS_TY_PROJECTION);
                 self.add_projection_ty(data);

compiler/rustc_middle/src/ty/layout.rs

@@ -637,7 +637,9 @@ where
                 }
             };
 
-            match *this.ty.kind() {
+            let ty = tcx.peel_off_ty_alias(this.ty);
+
+            match *ty.kind() {
                 ty::Bool
                 | ty::Char
                 | ty::Int(_)
@@ -770,6 +772,7 @@ where
                 | ty::Opaque(..)
                 | ty::Param(_)
                 | ty::Infer(_)
+                | ty::TyAlias(_, _)
                 | ty::Error(_) => bug!("TyAndLayout::field: unexpected type `{}`", this.ty),
             }
         }

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

@@ -264,6 +264,10 @@ fn characteristic_def_id_of_type_cached<'a>(
             return None;
         }),
 
+        // `TyAlias` always return `None` since the type alias' defining module is irrelevant for
+        // any decisions.
+        ty::TyAlias(..) => None,
+
         ty::FnDef(def_id, _)
         | ty::Closure(def_id, _)
         | ty::Generator(def_id, _, _)

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

@@ -780,6 +780,7 @@ pub trait PrettyPrinter<'tcx>:
                 p!("]")
             }
             ty::Slice(ty) => p!("[", print(ty), "]"),
+            ty::TyAlias(def_id, substs) => p!(print_def_path(def_id, substs)),
         }
 
         Ok(self)

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -639,6 +639,7 @@ impl<'tcx> TypeSuperFoldable<'tcx> for Ty<'tcx> {
             ty::Closure(did, substs) => ty::Closure(did, substs.try_fold_with(folder)?),
             ty::Projection(data) => ty::Projection(data.try_fold_with(folder)?),
             ty::Opaque(did, substs) => ty::Opaque(did, substs.try_fold_with(folder)?),
+            ty::TyAlias(did, substs) => ty::TyAlias(did, substs.try_fold_with(folder)?),
 
             ty::Bool
             | ty::Char
@@ -685,6 +686,7 @@ impl<'tcx> TypeSuperVisitable<'tcx> for Ty<'tcx> {
             ty::Closure(_did, ref substs) => substs.visit_with(visitor),
             ty::Projection(ref data) => data.visit_with(visitor),
             ty::Opaque(_, ref substs) => substs.visit_with(visitor),
+            ty::TyAlias(_, ref substs) => substs.visit_with(visitor),
 
             ty::Bool
             | ty::Char