Add TyKind::TyAlias support in rustc_typeck

Author: GuillaumeGomez

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -856,6 +856,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
         // Const parameters are well formed if their type is structural match.
         hir::GenericParamKind::Const { ty: hir_ty, default: _ } => {
             let ty = tcx.type_of(tcx.hir().local_def_id(param.hir_id));
+            let ty = tcx.peel_off_ty_alias(ty);
 
             if tcx.features().adt_const_params {
                 if let Some(non_structural_match_ty) =

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -187,6 +187,8 @@ impl<'tcx> InherentCollect<'tcx> {
         };
 
         let self_ty = self.tcx.type_of(item.def_id);
+        let self_ty = self.tcx.peel_off_ty_alias(self_ty);
+
         match *self_ty.kind() {
             ty::Adt(def, _) => {
                 self.check_def_id(item, self_ty, def.did());
@@ -197,6 +199,9 @@ impl<'tcx> InherentCollect<'tcx> {
             ty::Dynamic(data, ..) if data.principal_def_id().is_some() => {
                 self.check_def_id(item, self_ty, data.principal_def_id().unwrap());
             }
+            ty::TyAlias(..) => {
+                span_bug!(ty.span, "unexpected TyAlias in InherentCollect::check_item");
+            }
             ty::Dynamic(..) => {
                 struct_span_err!(
                     self.tcx.sess,

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -49,6 +49,8 @@ fn do_orphan_check_impl<'tcx>(
     let sp = tcx.def_span(def_id);
     let tr = impl_.of_trait.as_ref().unwrap();
 
+    let trait_ref = tcx.peel_off_ty_alias(trait_ref);
+
     // Ensure no opaque types are present in this impl header. See issues #76202 and #86411 for examples,
     // and #84660 where it would otherwise allow unsoundness.
     if trait_ref.has_opaque_types() {

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -257,6 +257,10 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 self.add_constraints_from_invariant_substs(current, substs, variance);
             }
 
+            ty::TyAlias(_, substs) => {
+                self.add_constraints_from_invariant_substs(current, substs, variance);
+            }
+
             ty::Dynamic(data, r, _) => {
                 // The type `Foo<T+'a>` is contravariant w/r/t `'a`:
                 let contra = self.contravariant(variance);

compiler/rustc_hir_typeck/src/cast.rs

@@ -123,6 +123,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // We should really try to normalize here.
             ty::Projection(ref pi) => Some(PointerKind::OfProjection(pi)),
             ty::Opaque(def_id, substs) => Some(PointerKind::OfOpaque(def_id, substs)),
+            ty::TyAlias(..) => span_bug!(span, "unexpected TyAlias in pointer_kind"),
             ty::Param(ref p) => Some(PointerKind::OfParam(p)),
             // Insufficient type information.
             ty::Placeholder(..) | ty::Bound(..) | ty::Infer(_) => None,