Add TyKind::TyAlias support in rustc_infer

Author: GuillaumeGomez

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -456,7 +456,8 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
             | ty::Projection(..)
             | ty::Foreign(..)
             | ty::Param(..)
-            | ty::Opaque(..) => {
+            | ty::Opaque(..)
+            | ty::TyAlias(..) => {
                 if t.flags().intersects(self.needs_canonical_flags) {
                     t.super_fold_with(self)
                 } else {

compiler/rustc_infer/src/infer/freshen.rs

@@ -210,7 +210,8 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
             | ty::Param(..)
             | ty::Closure(..)
             | ty::GeneratorWitness(..)
-            | ty::Opaque(..) => t.super_fold_with(self),
+            | ty::Opaque(..)
+            | ty::TyAlias(..) => t.super_fold_with(self),
 
             ty::Placeholder(..) | ty::Bound(..) => bug!("unexpected type {:?}", t),
         }

compiler/rustc_infer/src/infer/opaque_types.rs

@@ -52,7 +52,7 @@ impl<'tcx> InferCtxt<'tcx> {
         span: Span,
         param_env: ty::ParamEnv<'tcx>,
     ) -> InferOk<'tcx, T> {
-        if !value.has_opaque_types() {
+        if !value.has_opaque_types() && !value.has_ty_alias() {
             return InferOk { value, obligations: vec![] };
         }
         let mut obligations = vec![];
@@ -61,7 +61,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 .as_local()
                 .map_or(false, |def_id| self.opaque_type_origin(def_id, span).is_some())
         };
-        let value = value.fold_with(&mut ty::fold::BottomUpFolder {
+        let value = self.tcx.peel_off_ty_alias(value).fold_with(&mut ty::fold::BottomUpFolder {
             tcx: self.tcx,
             lt_op: |lt| lt,
             ct_op: |ct| ct,
@@ -548,6 +548,9 @@ impl<'tcx> InferCtxt<'tcx> {
         let item_bounds = tcx.bound_explicit_item_bounds(def_id.to_def_id());
 
         for (predicate, _) in item_bounds.subst_iter_copied(tcx, substs) {
+            debug!(?predicate);
+            let predicate = tcx.peel_off_ty_alias(predicate);
+
             let predicate = predicate.fold_with(&mut BottomUpFolder {
                 tcx,
                 ty_op: |ty| match *ty.kind() {

compiler/rustc_infer/src/infer/outlives/components.rs

@@ -169,6 +169,10 @@ fn compute_components<'tcx>(
                 out.push(Component::UnresolvedInferenceVariable(infer_ty));
             }
 
+            ty::TyAlias(def_id, _) => {
+                compute_components(tcx, tcx.type_of(def_id), out, visited);
+            }
+
             // Most types do not introduce any region binders, nor
             // involve any other subtle cases, and so the WF relation
             // simply constraints any regions referenced directly by