update PlaceTy to use ty::Variant

Author: zhamlin

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -400,6 +400,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
                     self.infcx.tcx.hir().name(var_id).to_string()
                 }
+                ty::Variant(ty, index) => {
+                    assert_eq!(index, variant_index.unwrap());
+                    return self.describe_field_from_ty(ty, field, variant_index);
+                }
                 _ => {
                     // Might need a revision when the fields in trait RFC is implemented
                     // (https://github.com/rust-lang/rfcs/pull/1546)

compiler/rustc_borrowck/src/places_conflict.rs

@@ -243,10 +243,10 @@ fn place_components_conflict<'tcx>(
                     return false;
                 }
 
-                (ProjectionElem::Field { .. }, ty::Adt(def, _), AccessDepth::Drop) => {
+                (ProjectionElem::Field { .. }, _, AccessDepth::Drop) => {
                     // Drop can read/write arbitrary projections, so places
                     // conflict regardless of further projections.
-                    if def.has_dtor(tcx) {
+                    if base_ty.has_dtor(tcx) {
                         return true;
                     }
                 }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -556,7 +556,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
         let mut place_ty = PlaceTy::from_ty(self.body.local_decls[place.local].ty);
 
         for elem in place.projection.iter() {
-            if place_ty.variant_index.is_none() {
+            if place_ty.variant_index().is_none() {
                 if place_ty.ty.references_error() {
                     assert!(self.errors_reported);
                     return PlaceTy::from_ty(self.tcx().ty_error());
@@ -735,7 +735,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
                             adt_def.variants.len()
                         ))
                     } else {
-                        PlaceTy { ty: base_ty, variant_index: Some(index) }
+                        PlaceTy { ty: self.tcx().mk_ty(ty::Variant(base_ty, index)) }
                     }
                 }
                 // We do not need to handle generators here, because this runs
@@ -802,9 +802,10 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
         location: Location,
     ) -> Result<Ty<'tcx>, FieldAccessError> {
         let tcx = self.tcx();
+        let ty = base_ty.ty;
 
-        let (variant, substs) = match base_ty {
-            PlaceTy { ty, variant_index: Some(variant_index) } => match *ty.kind() {
+        let (variant, substs) = if let ty::Variant(ty, variant_index) = *ty.kind() {
+            match *ty.kind() {
                 ty::Adt(adt_def, substs) => (&adt_def.variants[variant_index], substs),
                 ty::Generator(def_id, substs, _) => {
                     let mut variants = substs.as_generator().state_tys(def_id, tcx);
@@ -822,8 +823,9 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
                     };
                 }
                 _ => bug!("can't have downcast of non-adt non-generator type"),
-            },
-            PlaceTy { ty, variant_index: None } => match *ty.kind() {
+            }
+        } else {
+            match *ty.kind() {
                 ty::Adt(adt_def, substs) if !adt_def.is_enum() => {
                     (&adt_def.variants[VariantIdx::new(0)], substs)
                 }
@@ -863,7 +865,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
                         base_ty
                     ));
                 }
-            },
+            }
         };
 
         if let Some(field) = variant.fields.get(field.index()) {

compiler/rustc_middle/src/mir/tcx.rs

@@ -12,18 +12,23 @@ use rustc_target::abi::VariantIdx;
 #[derive(Copy, Clone, Debug, TypeFoldable)]
 pub struct PlaceTy<'tcx> {
     pub ty: Ty<'tcx>,
-    /// Downcast to a particular variant of an enum, if included.
-    pub variant_index: Option<VariantIdx>,
 }
 
 // At least on 64 bit systems, `PlaceTy` should not be larger than two or three pointers.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-static_assert_size!(PlaceTy<'_>, 16);
+static_assert_size!(PlaceTy<'_>, 8);
 
 impl<'tcx> PlaceTy<'tcx> {
     #[inline]
     pub fn from_ty(ty: Ty<'tcx>) -> PlaceTy<'tcx> {
-        PlaceTy { ty, variant_index: None }
+        PlaceTy { ty }
+    }
+
+    pub fn variant_index(self) -> Option<VariantIdx> {
+        match self.ty.kind() {
+            ty::Variant(_, index) => Some(*index),
+            _ => None,
+        }
     }
 
     /// `place_ty.field_ty(tcx, f)` computes the type at a given field
@@ -35,15 +40,16 @@ impl<'tcx> PlaceTy<'tcx> {
     /// Note that the resulting type has not been normalized.
     pub fn field_ty(self, tcx: TyCtxt<'tcx>, f: &Field) -> Ty<'tcx> {
         let answer = match self.ty.kind() {
+            ty::Variant(ty, variant_index) => match ty.kind() {
+                ty::Adt(adt_def, substs) => {
+                    assert!(adt_def.is_enum());
+                    let field_def = &adt_def.variants[*variant_index].fields[f.index()];
+                    field_def.ty(tcx, substs)
+                }
+                _ => bug!("unexpected type: {}", ty),
+            },
             ty::Adt(adt_def, substs) => {
-                let variant_def = match self.variant_index {
-                    None => adt_def.non_enum_variant(),
-                    Some(variant_index) => {
-                        assert!(adt_def.is_enum());
-                        &adt_def.variants[variant_index]
-                    }
-                };
-                let field_def = &variant_def.fields[f.index()];
+                let field_def = &adt_def.non_enum_variant().fields[f.index()];
                 field_def.ty(tcx, substs)
             }
             ty::Tuple(ref tys) => tys[f.index()].expect_ty(),
@@ -103,7 +109,7 @@ impl<'tcx> PlaceTy<'tcx> {
                 })
             }
             ProjectionElem::Downcast(_name, index) => {
-                PlaceTy { ty: self.ty, variant_index: Some(index) }
+                PlaceTy { ty: tcx.mk_ty(ty::Variant(self.ty, index)) }
             }
             ProjectionElem::Field(ref f, ref fty) => PlaceTy::from_ty(handle_field(&self, f, fty)),
         };

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -104,7 +104,7 @@ pub fn simplify_type(
         ty::Opaque(def_id, _) => Some(OpaqueSimplifiedType(def_id)),
         ty::Foreign(def_id) => Some(ForeignSimplifiedType(def_id)),
         ty::Placeholder(..) | ty::Bound(..) | ty::Infer(_) | ty::Error(_) => None,
-        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+        ty::Variant(ty, _) => return simplify_type(tcx, ty, can_simplify_params),
     }
 }
 

compiler/rustc_middle/src/ty/flags.rs

@@ -214,7 +214,7 @@ impl FlagComputation {
                 computation.add_ty(fn_sig.output());
             }),
 
-            &ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+            &ty::Variant(ty, _) => self.add_kind(ty.kind()),
         }
     }
 

compiler/rustc_middle/src/ty/layout.rs

@@ -1403,7 +1403,8 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             ty::Bound(..) | ty::Param(_) | ty::Error(_) => {
                 return Err(LayoutError::Unknown(ty));
             }
-            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+
+            ty::Variant(ty, _) => return self.layout_of_uncached(ty),
         })
     }
 }

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -903,7 +903,8 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             | ty::Placeholder(..)
             | ty::Never
             | ty::Foreign(..) => return self,
-            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+
+            ty::Variant(ty, _) => return ty.super_fold_with(folder),
         };
 
         if *self.kind() == kind { self } else { folder.tcx().mk_ty(kind) }
@@ -952,7 +953,8 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             | ty::Param(..)
             | ty::Never
             | ty::Foreign(..) => ControlFlow::CONTINUE,
-            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+
+            ty::Variant(ty, _) => return ty.super_visit_with(visitor),
         }
     }
 

compiler/rustc_middle/src/ty/sty.rs

@@ -1905,6 +1905,14 @@ impl<'tcx> TyS<'tcx> {
         !matches!(self.kind(), Param(_) | Infer(_) | Error(_))
     }
 
+    pub fn has_dtor(&self, tcx: TyCtxt<'tcx>) -> bool {
+        match self.kind() {
+            Adt(adt_def, _) => adt_def.has_dtor(tcx),
+            Variant(ty, _) => ty.has_dtor(tcx),
+            _ => false,
+        }
+    }
+
     /// Returns the type and mutability of `*ty`.
     ///
     /// The parameter `explicit` indicates if this is an *explicit* dereference.
@@ -2196,6 +2204,13 @@ impl<'tcx> TyS<'tcx> {
             ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
+
+    pub fn strip_variant_type(&self) -> &Self {
+        match self.kind() {
+            ty::Variant(ty, ..) => *ty,
+            _ => self,
+        }
+    }
 }
 
 /// Extra information about why we ended up with a particular variance.

compiler/rustc_middle/src/ty/util.rs

@@ -712,7 +712,8 @@ impl<'tcx> ty::TyS<'tcx> {
             | ty::Param(_)
             | ty::Placeholder(_)
             | ty::Projection(_) => false,
-            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+
+            ty::Variant(ty, _) => return ty.is_trivially_freeze(),
         }
     }
 
@@ -1026,7 +1027,8 @@ pub fn needs_drop_components(
         | ty::Infer(_)
         | ty::Closure(..)
         | ty::Generator(..) => Ok(smallvec![ty]),
-        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+
+        ty::Variant(ty, _) => return needs_drop_components(ty, target_layout),
     }
 }
 

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

@@ -1998,7 +1998,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 t.rebind(vec![self.tcx().type_of(def_id).subst(self.tcx(), substs)])
             }
 
-            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+            ty::Variant(ty, _) => return self.constituent_types_for_ty(t.rebind(ty)),
         }
     }
 

compiler/rustc_trait_selection/src/traits/structural_match.rs

@@ -211,7 +211,7 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for Search<'a, 'tcx> {
                 return ControlFlow::CONTINUE;
             }
 
-            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
+            ty::Variant(ty, _) => return self.visit_ty(ty),
         };
 
         if !self.seen.insert(adt_def.did) {