Ignore Infer sty when relating MIR and user Ty

src/librustc/mir/tcx.rs

@@ -25,6 +25,9 @@ static_assert!(PLACE_TY_IS_3_PTRS_LARGE:
     mem::size_of::<PlaceTy<'_>>() <= 24
 );
 
+#[derive(Debug)]
+pub struct HitTyVar;
+
 impl<'a, 'gcx, 'tcx> PlaceTy<'tcx> {
     pub fn from_ty(ty: Ty<'tcx>) -> PlaceTy<'tcx> {
         PlaceTy::Ty { ty }
@@ -75,7 +78,7 @@ impl<'a, 'gcx, 'tcx> PlaceTy<'tcx> {
                          elem: &PlaceElem<'tcx>)
                          -> PlaceTy<'tcx>
     {
-        self.projection_ty_core(tcx, elem, |_, _, ty| -> Result<Ty<'tcx>, ()> { Ok(ty) })
+        self.projection_ty_core(tcx, elem, |_, _, ty| -> Result<Ty<'tcx>, HitTyVar> { Ok(ty) })
             .unwrap()
     }
 
@@ -84,14 +87,14 @@ impl<'a, 'gcx, 'tcx> PlaceTy<'tcx> {
     /// `Ty` or downcast variant corresponding to that projection.
     /// The `handle_field` callback must map a `Field` to its `Ty`,
     /// (which should be trivial when `T` = `Ty`).
-    pub fn projection_ty_core<V, T, E>(
+    pub fn projection_ty_core<V, T>(
         self,
         tcx: TyCtxt<'a, 'gcx, 'tcx>,
         elem: &ProjectionElem<'tcx, V, T>,
-        mut handle_field: impl FnMut(&Self, &Field, &T) -> Result<Ty<'tcx>, E>)
-        -> Result<PlaceTy<'tcx>, E>
-    where
-        V: ::std::fmt::Debug, T: ::std::fmt::Debug
+        mut handle_field: impl FnMut(&Self, &Field, &T) -> Result<Ty<'tcx>, HitTyVar>,
+    ) -> Result<PlaceTy<'tcx>, HitTyVar>
+        where
+            V: ::std::fmt::Debug, T: ::std::fmt::Debug
     {
         let answer = match *elem {
             ProjectionElem::Deref => {
@@ -135,8 +138,16 @@ impl<'a, 'gcx, 'tcx> PlaceTy<'tcx> {
                                             substs,
                                             variant_index: index }
                     }
-                    _ => {
-                        bug!("cannot downcast non-ADT type: `{:?}`", self)
+                    ty::Infer(..) => {  // #57866
+                        return Err(HitTyVar);
+                    }
+                    ref sty => {
+                        bug!(
+                            "cannot downcast non-ADT type: `{:?}`, `{:?}`, `{:?}`",
+                            self,
+                            sty,
+                            adt_def1,
+                        );
                     }
                 },
             ProjectionElem::Field(ref f, ref fty) =>

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -27,7 +27,7 @@ use rustc::infer::canonical::QueryRegionConstraint;
 use rustc::infer::outlives::env::RegionBoundPairs;
 use rustc::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime, NLLRegionVariableOrigin};
 use rustc::mir::interpret::EvalErrorKind::BoundsCheck;
-use rustc::mir::tcx::PlaceTy;
+use rustc::mir::tcx::{PlaceTy, HitTyVar};
 use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext, NonMutatingUseContext};
 use rustc::mir::*;
 use rustc::traits::query::type_op;
@@ -1079,7 +1079,6 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                 //
                 // if we hit a ty var as we descend, then just skip the
                 // attempt to relate the mir local with any type.
-                #[derive(Debug)] struct HitTyVar;
                 let mut curr_projected_ty: Result<PlaceTy, HitTyVar>;
 
                 curr_projected_ty = Ok(PlaceTy::from_ty(ty));

src/librustc_traits/type_op.rs

@@ -3,7 +3,7 @@ use rustc::infer::canonical::{Canonical, QueryResponse};
 use rustc::infer::InferCtxt;
 use rustc::hir::def_id::DefId;
 use rustc::mir::ProjectionKind;
-use rustc::mir::tcx::PlaceTy;
+use rustc::mir::tcx::{PlaceTy, HitTyVar};
 use rustc::traits::query::type_op::ascribe_user_type::AscribeUserType;
 use rustc::traits::query::type_op::eq::Eq;
 use rustc::traits::query::type_op::normalize::Normalize;
@@ -133,7 +133,6 @@ impl AscribeUserTypeCx<'me, 'gcx, 'tcx> {
         // if we hit a ty var as we descend, then just skip the
         // attempt to relate the mir local with any type.
 
-        struct HitTyVar;
         let mut curr_projected_ty: Result<PlaceTy, HitTyVar>;
         curr_projected_ty = Ok(PlaceTy::from_ty(ty));
         for proj in projs {

src/test/ui/issues/issue-57866.rs

@@ -0,0 +1,26 @@
+// run-pass
+
+#![feature(type_alias_enum_variants)]
+
+enum Outer<T> {
+    A(T)
+}
+
+enum Inner {
+    A(i32)
+}
+
+type OuterAlias = Outer<Inner>;
+
+fn ice(x: OuterAlias) {
+    // Fine
+    match x {
+        OuterAlias::A(Inner::A(_)) => (),
+    }
+    // Not fine
+    match x {
+        OuterAlias::A(Inner::A(y)) => (),
+    }
+}
+
+fn main() {}