enum variant support

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -744,6 +744,22 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
                         PlaceTy { ty: base_ty, variant_index: Some(index) }
                     }
                 }
+                ty::Variant(ty, _) => match ty.kind() {
+                    ty::Adt(adt_def, _substs) if adt_def.is_enum() => {
+                        if index.as_usize() >= adt_def.variants.len() {
+                            PlaceTy::from_ty(span_mirbug_and_err!(
+                                self,
+                                place,
+                                "cast to variant #{:?} but enum only has {:?}",
+                                index,
+                                adt_def.variants.len()
+                            ))
+                        } else {
+                            PlaceTy { ty: *ty, variant_index: Some(index) }
+                        }
+                    }
+                    _ => bug!("unexpected type: {:?}", ty.kind()),
+                },
                 // We do not need to handle generators here, because this runs
                 // before the generator transform stage.
                 _ => {
@@ -812,6 +828,12 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
         let (variant, substs) = match base_ty {
             PlaceTy { ty, variant_index: Some(variant_index) } => match *ty.kind() {
                 ty::Adt(adt_def, substs) => (&adt_def.variants[variant_index], substs),
+                ty::Variant(ty, _) => match ty.kind() {
+                    ty::Adt(adt_def, substs) => {
+                        (adt_def.variants.get(variant_index).expect(""), *substs)
+                    }
+                    _ => bug!("unexpected type: {:?}", ty.kind()),
+                },
                 ty::Generator(def_id, substs, _) => {
                     let mut variants = substs.as_generator().state_tys(def_id, tcx);
                     let mut variant = match variants.nth(variant_index.into()) {
@@ -833,6 +855,12 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
                 ty::Adt(adt_def, substs) if !adt_def.is_enum() => {
                     (&adt_def.variants[VariantIdx::new(0)], substs)
                 }
+                ty::Variant(ty, _) => match ty.kind() {
+                    ty::Adt(adt_def, substs) if adt_def.is_enum() => {
+                        (&adt_def.variants[VariantIdx::new(0)], *substs)
+                    }
+                    _ => bug!("unexpected type: {:?}", ty.kind()),
+                },
                 ty::Closure(_, substs) => {
                     return match substs
                         .as_closure()

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -373,6 +373,7 @@ fn push_debuginfo_type_name<'tcx>(
                 t
             );
         }
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 
     /// MSVC names enums differently than other platforms so that the debugging visualization

compiler/rustc_const_eval/src/const_eval/mod.rs

@@ -129,6 +129,7 @@ fn const_to_valtree_inner<'tcx>(
         | ty::Closure(..)
         | ty::Generator(..)
         | ty::GeneratorWitness(..) => None,
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 }
 

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -100,6 +100,7 @@ crate fn eval_nullary_intrinsic<'tcx>(
             | ty::Never
             | ty::Tuple(_)
             | ty::Error(_) => ConstValue::from_machine_usize(0u64, &tcx),
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         },
         other => bug!("`{}` is not a zero arg intrinsic", other),
     })

compiler/rustc_const_eval/src/interpret/intrinsics/type_name.rs

@@ -65,6 +65,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
             ty::Foreign(def_id) => self.print_def_path(def_id, &[]),
 
             ty::GeneratorWitness(_) => bug!("type_name: unexpected `GeneratorWitness`"),
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -683,7 +683,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let discr_val = self.cast_from_scalar(tag_bits, tag_layout, discr_layout.ty);
                 let discr_bits = discr_val.assert_bits(discr_layout.size);
                 // Convert discriminant to variant index, and catch invalid discriminants.
-                let index = match *op.layout.ty.kind() {
+                let index = match *op.layout.ty.strip_variant_type().kind() {
                     ty::Adt(adt, _) => {
                         adt.discriminants(*self.tcx).find(|(_, var)| var.val == discr_bits)
                     }
@@ -693,6 +693,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                             .discriminants(def_id, *self.tcx)
                             .find(|(_, var)| var.val == discr_bits)
                     }
+                    ty::Variant(..) => unreachable!(),
                     _ => span_bug!(self.cur_span(), "tagged layout for non-adt non-generator"),
                 }
                 .ok_or_else(|| err_ub!(InvalidTag(Scalar::from_uint(tag_bits, tag_layout.size))))?;

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -217,7 +217,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
         match layout.variants {
             Variants::Multiple { tag_field, .. } => {
                 if tag_field == field {
-                    return match layout.ty.kind() {
+                    return match layout.ty.strip_variant_type().kind() {
                         ty::Adt(def, ..) if def.is_enum() => PathElem::EnumTag,
                         ty::Generator(..) => PathElem::GeneratorTag,
                         _ => bug!("non-variant type {:?}", layout.ty),
@@ -228,7 +228,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
         }
 
         // Now we know we are projecting to a field, so figure out which one.
-        match layout.ty.kind() {
+        match layout.ty.strip_variant_type().kind() {
             // generators and closures.
             ty::Closure(def_id, _) | ty::Generator(def_id, _, _) => {
                 let mut name = None;
@@ -495,7 +495,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
     ) -> InterpResult<'tcx, bool> {
         // Go over all the primitive types
         let ty = value.layout.ty;
-        match ty.kind() {
+        match ty.strip_variant_type().kind() {
             ty::Bool => {
                 let value = self.read_scalar(value)?;
                 try_validation!(
@@ -612,6 +612,8 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
             | ty::Opaque(..)
             | ty::Projection(..)
             | ty::GeneratorWitness(..) => bug!("Encountered invalid type {:?}", ty),
+
+            ty::Variant(..) => unreachable!(),
         }
     }
 
@@ -727,11 +729,12 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
         variant_id: VariantIdx,
         new_op: &OpTy<'tcx, M::PointerTag>,
     ) -> InterpResult<'tcx> {
-        let name = match old_op.layout.ty.kind() {
+        let ty = old_op.layout.ty.strip_variant_type();
+        let name = match ty.kind() {
             ty::Adt(adt, _) => PathElem::Variant(adt.variants[variant_id].ident.name),
             // Generators also have variants
             ty::Generator(..) => PathElem::GeneratorState(variant_id),
-            _ => bug!("Unexpected type with variant: {:?}", old_op.layout.ty),
+            _ => bug!("Unexpected type with variant: {:?}", ty),
         };
         self.with_elem(name, move |this| this.visit_value(new_op))
     }

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

@@ -385,6 +385,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
             | ty::Uint(..)
             | ty::Float(..)
             | ty::Adt(..)
+            | ty::Variant(..)
             | ty::Str
             | ty::Error(_)
             | ty::Array(..)

compiler/rustc_infer/src/infer/freshen.rs

@@ -199,6 +199,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
             | ty::Uint(..)
             | ty::Float(..)
             | ty::Adt(..)
+            | ty::Variant(..) 
             | ty::Str
             | ty::Error(_)
             | ty::Array(..)

compiler/rustc_lint/src/types.rs

@@ -1130,6 +1130,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             | ty::GeneratorWitness(..)
             | ty::Placeholder(..)
             | ty::FnDef(..) => bug!("unexpected type in foreign function: {:?}", ty),
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

compiler/rustc_middle/src/ty/cast.rs

@@ -59,6 +59,7 @@ impl<'tcx> CastTy<'tcx> {
             ty::Uint(u) => Some(CastTy::Int(IntTy::U(u))),
             ty::Float(_) => Some(CastTy::Float),
             ty::Adt(d, _) if d.is_enum() && d.is_payloadfree() => Some(CastTy::Int(IntTy::CEnum)),
+            ty::Variant(ty, _) => Self::from_ty(ty),
             ty::RawPtr(mt) => Some(CastTy::Ptr(mt)),
             ty::FnPtr(..) => Some(CastTy::FnPtr),
             _ => None,

compiler/rustc_middle/src/ty/codec.rs

@@ -307,7 +307,7 @@ macro_rules! impl_decodable_via_ref {
         })*
     }
 }
-
+// TODO(zhamlin): enum variant here?
 impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::AdtDef {
     fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> {
         let def_id = <DefId as Decodable<D>>::decode(decoder)?;

compiler/rustc_middle/src/ty/context.rs

@@ -1919,6 +1919,7 @@ impl<'tcx> TyCtxt<'tcx> {
                     fmt,
                     self.0,
                     Adt,
+                    Variant,
                     Array,
                     Slice,
                     RawPtr,

compiler/rustc_middle/src/ty/error.rs

@@ -244,6 +244,7 @@ impl<'tcx> ty::TyS<'tcx> {
             ty::Tuple(ref tys) if tys.is_empty() => format!("`{}`", self).into(),
 
             ty::Adt(def, _) => format!("{} `{}`", def.descr(), tcx.def_path_str(def.did)).into(),
+            ty::Variant(ty, _) => ty.sort_string(tcx),
             ty::Foreign(def_id) => format!("extern type `{}`", tcx.def_path_str(def_id)).into(),
             ty::Array(t, n) => {
                 if t.is_simple_ty() {
@@ -315,6 +316,10 @@ impl<'tcx> ty::TyS<'tcx> {
             | ty::Never => "type".into(),
             ty::Tuple(ref tys) if tys.is_empty() => "unit type".into(),
             ty::Adt(def, _) => def.descr().into(),
+            ty::Variant(ty, _) => match ty.kind() {
+                ty::Adt(def, _) => format!("{} variant", def.descr()).into(),
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            },
             ty::Foreign(_) => "extern type".into(),
             ty::Array(..) => "array".into(),
             ty::Slice(_) => "slice".into(),

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -66,6 +66,7 @@ pub fn simplify_type(
         ty::Uint(uint_type) => Some(UintSimplifiedType(uint_type)),
         ty::Float(float_type) => Some(FloatSimplifiedType(float_type)),
         ty::Adt(def, _) => Some(AdtSimplifiedType(def.did)),
+        ty::Variant(ty, _) => simplify_type(tcx, ty, can_simplify_params),
         ty::Str => Some(StrSimplifiedType),
         ty::Array(..) | ty::Slice(_) => Some(ArraySimplifiedType),
         ty::RawPtr(_) => Some(PtrSimplifiedType),

compiler/rustc_middle/src/ty/flags.rs

@@ -161,6 +161,8 @@ impl FlagComputation {
                 self.add_substs(substs);
             }
 
+            &ty::Variant(ty, _) => self.add_kind(ty.kind()),
+
             &ty::Projection(data) => {
                 self.add_flags(TypeFlags::HAS_TY_PROJECTION);
                 self.add_projection_ty(data);

compiler/rustc_middle/src/ty/layout.rs

@@ -1394,6 +1394,8 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 tcx.intern_layout(best_layout)
             }
 
+            ty::Variant(ty, _) => self.layout_of_uncached(ty)?,
+
             // Types with no meaningful known layout.
             ty::Projection(_) | ty::Opaque(..) => {
                 // NOTE(eddyb) `layout_of` query should've normalized these away,
@@ -2386,6 +2388,24 @@ where
                     }
                 }
 
+                ty::Variant(ty, _) => match ty.kind() {
+                    ty::Adt(def, substs) => match this.variants {
+                        Variants::Single { index } => {
+                            return TyMaybeWithLayout::Ty(
+                                def.variants[index].fields[i].ty(tcx, substs),
+                            );
+                        }
+
+                        // Discriminant field for enums (where applicable).
+                        Variants::Multiple { tag, .. } => {
+                            // TODO(zhamlin): make this work
+                            assert_eq!(i, 0);
+                            return TyMaybeWithLayout::TyAndLayout(tag_layout(tag));
+                        }
+                    },
+                    _ => bug!("unexpected type: {:?}", ty.kind()),
+                },
+
                 ty::Projection(_)
                 | ty::Bound(..)
                 | ty::Placeholder(..)

compiler/rustc_middle/src/ty/outlives.rs

@@ -166,6 +166,7 @@ fn compute_components(
             ty::Float(..) |       // OutlivesScalar
             ty::Never |           // ...
             ty::Adt(..) |         // OutlivesNominalType
+            ty::Variant(..) |     // OutlivesNominalType
             ty::Opaque(..) |      // OutlivesNominalType (ish)
             ty::Foreign(..) |     // OutlivesNominalType
             ty::Str |             // OutlivesScalar (ish)

compiler/rustc_middle/src/ty/print/mod.rs

@@ -315,6 +315,7 @@ fn characteristic_def_id_of_type_cached<'a>(
         | ty::GeneratorWitness(..)
         | ty::Never
         | ty::Float(_) => None,
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 }
 pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -597,6 +597,14 @@ pub trait PrettyPrinter<'tcx>:
             ty::Adt(def, substs) => {
                 p!(print_def_path(def.did, substs));
             }
+
+            ty::Variant(ty, idx) => match ty.kind() {
+                ty::Adt(def, substs) => {
+                    p!(print_def_path(def.did, substs));
+                    p!(write("::{}", def.variants.get(idx).unwrap().ident.name));
+                }
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            },
             ty::Dynamic(data, r) => {
                 let print_r = self.region_should_not_be_omitted(r);
                 if print_r {

compiler/rustc_middle/src/ty/relate.rs

@@ -402,6 +402,30 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
             Ok(tcx.mk_adt(a_def, substs))
         }
 
+        // TODO(zhamlin): handle this somewhere else?
+        // Enum <- Enum Variant
+        (&ty::Adt(a_def, a_substs), &ty::Variant(b_ty, _)) if relation.a_is_expected() => {
+            match b_ty.kind() {
+                ty::Adt(b_def, b_substs) if a_def == *b_def => {
+                    let substs = relation.relate_item_substs(a_def.did, a_substs, b_substs)?;
+                    Ok(tcx.mk_adt(a_def, substs))
+                }
+                _ => Err(TypeError::Sorts(expected_found(relation, a, b))),
+            }
+        }
+
+        (&ty::Variant(a_ty, _), &ty::Adt(b_def, b_substs)) => match a_ty.kind() {
+            ty::Adt(a_def, a_substs) if *a_def == b_def => {
+                let substs = relation.relate_item_substs(a_def.did, a_substs, b_substs)?;
+                Ok(tcx.mk_adt(a_def, substs))
+            }
+            _ => Err(TypeError::Sorts(expected_found(relation, a, b))),
+        },
+
+        (&ty::Variant(a_ty, a_idx), &ty::Variant(b_ty, b_idx)) if a_idx == b_idx => {
+            relation.relate(a_ty, b_ty).map(|ty| tcx.mk_ty(ty::Variant(ty, a_idx)))
+        }
+
         (&ty::Foreign(a_id), &ty::Foreign(b_id)) if a_id == b_id => Ok(tcx.mk_foreign(a_id)),
 
         (&ty::Dynamic(a_obj, a_region), &ty::Dynamic(b_obj, b_region)) => {

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -871,6 +871,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             ty::Array(typ, sz) => ty::Array(typ.fold_with(folder), sz.fold_with(folder)),
             ty::Slice(typ) => ty::Slice(typ.fold_with(folder)),
             ty::Adt(tid, substs) => ty::Adt(tid, substs.fold_with(folder)),
+            ty::Variant(ty, idx) => ty::Variant(ty.fold_with(folder), idx),
             ty::Dynamic(trait_ty, region) => {
                 ty::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder))
             }
@@ -917,6 +918,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             }
             ty::Slice(typ) => typ.visit_with(visitor),
             ty::Adt(_, substs) => substs.visit_with(visitor),
+            ty::Variant(ty, _idx) => ty.visit_with(visitor),
             ty::Dynamic(ref trait_ty, ref reg) => {
                 trait_ty.visit_with(visitor)?;
                 reg.visit_with(visitor)