Fix compilation errors for TyAlias

Author: GuillaumeGomez

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -12,7 +12,7 @@ use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_middle::ty::fast_reject::{simplify_type, SimplifiedType, TreatParams};
-use rustc_middle::ty::{self, CrateInherentImpls, Ty, TyCtxt};
+use rustc_middle::ty::{self, CrateInherentImpls, Subst, Ty, TyCtxt};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 

compiler/rustc_hir_typeck/src/cast.rs

@@ -123,7 +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::TyAlias(..) => bug!("unexpected TyAlias in pointer_kind"),
             ty::Param(ref p) => Some(PointerKind::OfParam(p)),
             // Insufficient type information.
             ty::Placeholder(..) | ty::Bound(..) | ty::Infer(_) => None,

compiler/rustc_middle/src/ty/layout.rs

@@ -670,7 +670,7 @@ where
                     // as the `Abi` or `FieldsShape` is checked by users.
                     if i == 0 {
                         let nil = tcx.mk_unit();
-                        let unit_ptr_ty = if this.ty.is_unsafe_ptr() {
+                        let unit_ptr_ty = if ty.is_unsafe_ptr() {
                             tcx.mk_mut_ptr(nil)
                         } else {
                             tcx.mk_mut_ref(tcx.lifetimes.re_static, nil)
@@ -680,7 +680,7 @@ where
                         // the `Result` should always work because the type is
                         // always either `*mut ()` or `&'static mut ()`.
                         return TyMaybeWithLayout::TyAndLayout(TyAndLayout {
-                            ty: this.ty,
+                            ty,
                             ..tcx.layout_of(ty::ParamEnv::reveal_all().and(unit_ptr_ty)).unwrap()
                         });
                     }
@@ -779,7 +779,7 @@ where
                 | ty::Param(_)
                 | ty::Infer(_)
                 | ty::TyAlias(_, _)
-                | ty::Error(_) => bug!("TyAndLayout::field: unexpected type `{}`", this.ty),
+                | ty::Error(_) => bug!("TyAndLayout::field: unexpected type `{}`", ty),
             }
         }
 

compiler/rustc_privacy/src/lib.rs

@@ -28,7 +28,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::abstract_const::{walk_abstract_const, AbstractConst, Node as ACNode};
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::subst::InternalSubsts;
-use rustc_middle::ty::{self, Const, DefIdTree, GenericParamDefKind};
+use rustc_middle::ty::{self, Const, DefIdTree, GenericParamDefKind, Subst};
 use rustc_middle::ty::{TraitRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
 use rustc_session::lint;
 use rustc_span::hygiene::Transparency;
@@ -275,7 +275,6 @@ where
             | ty::FnPtr(..)
             | ty::Param(..)
             | ty::Error(_)
-            | ty::TyAlias(..)
             | ty::GeneratorWitness(..) => {}
             ty::Bound(..) | ty::Placeholder(..) | ty::Infer(..) => {
                 bug!("unexpected type: {:?}", ty)

compiler/rustc_trait_selection/src/traits/project.rs

@@ -465,7 +465,12 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
         }
     }
 
-    fn fold_reveal(&mut self, ty: Ty<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
+    fn fold_alias_or_revealed_opaque(
+        &mut self,
+        ty: Ty<'tcx>,
+        def_id: DefId,
+        substs: SubstsRef<'tcx>,
+    ) -> Ty<'tcx> {
         let recursion_limit = self.tcx().recursion_limit();
         if !recursion_limit.value_within_limit(self.depth) {
             let obligation =
@@ -534,11 +539,11 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
                 // Only normalize `impl Trait` outside of type inference, usually in codegen.
                 match self.param_env.reveal() {
                     Reveal::UserFacing => ty.super_fold_with(self),
-                    Reveal::All => self.fold_reveal(ty, def_id, substs),
+                    Reveal::All => self.fold_alias_or_revealed_opaque(ty, def_id, substs),
                 }
             }
 
-            ty::TyAlias(def_id, substs) => self.fold_reveal(ty, def_id, substs),
+            ty::TyAlias(def_id, substs) => self.fold_alias_or_revealed_opaque(ty, def_id, substs),
 
             ty::Projection(data) if !data.has_escaping_bound_vars() => {
                 // This branch is *mostly* just an optimization: when we don't
@@ -1418,7 +1423,7 @@ fn assemble_candidates_from_trait_def<'cx, 'tcx>(
     let bounds = match *obligation.predicate.self_ty().kind() {
         ty::Projection(ref data) => tcx.bound_item_bounds(data.item_def_id).subst(tcx, data.substs),
         ty::Opaque(def_id, substs) => tcx.bound_item_bounds(def_id).subst(tcx, substs),
-        ty::TyAlias(def_id, substs) => tcx.bound_item_bounds(def_id).subst(tcx, substs),
+        // ty::TyAlias(def_id, substs) => tcx.bound_item_bounds(def_id).subst(tcx, substs),
         ty::Infer(ty::TyVar(_)) => {
             // If the self-type is an inference variable, then it MAY wind up
             // being a projected type, so induce an ambiguity.

compiler/rustc_trait_selection/src/traits/query/normalize.rs

@@ -166,7 +166,7 @@ struct QueryNormalizer<'cx, 'tcx> {
 }
 
 impl<'cx, 'tcx> QueryNormalizer<'cx, 'tcx> {
-    fn fold_reveal(
+    fn fold_alias_or_revealed_opaque(
         &mut self,
         ty: Ty<'tcx>,
         def_id: DefId,
@@ -238,11 +238,11 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
                 // Only normalize `impl Trait` outside of type inference, usually in codegen.
                 match self.param_env.reveal() {
                     Reveal::UserFacing => ty.try_super_fold_with(self),
-                    Reveal::All => self.fold_reveal(ty, def_id, substs),
+                    Reveal::All => self.fold_alias_or_revealed_opaque(ty, def_id, substs),
                 }
             }
 
-            ty::TyAlias(def_id, substs) => self.fold_reveal(ty, def_id, substs),
+            ty::TyAlias(def_id, substs) => self.fold_alias_or_revealed_opaque(ty, def_id, substs),
 
             ty::Projection(data) if !data.has_escaping_bound_vars() => {
                 // This branch is just an optimization: when we don't have escaping bound vars,

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -154,6 +154,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let (def_id, substs) = match *placeholder_self_ty.kind() {
             ty::Projection(proj) => (proj.item_def_id, proj.substs),
             ty::Opaque(def_id, substs) => (def_id, substs),
+            ty::TyAlias(def_id, substs) => (def_id, substs),
             _ => bug!("projection candidate for unexpected type: {:?}", placeholder_self_ty),
         };
 

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -907,8 +907,9 @@ impl<'tcx> WfPredicates<'tcx> {
                     ));
                 }
 
-                ty::TyAlias(..) => {
-                    bug!("unexpected TyAlias in WfPredicates::compute");
+                ty::TyAlias(did, substs) => {
+                    let obligations = self.nominal_obligations(did, substs);
+                    self.out.extend(obligations);
                 }
             }