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

@@ -687,6 +687,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     ty::Adt(adt, _) => {
                         adt.discriminants(*self.tcx).find(|(_, var)| var.val == discr_bits)
                     }
+                    ty::Variant(ty, _) => match ty.kind() {
+                        ty::Adt(adt, _) => adt.discriminants(*self.tcx).find(|(_, var)| var.val == discr_bits),
+                        _ => bug!("unexpected type: {:?}", ty.kind()),
+                    }
                     ty::Generator(def_id, substs, _) => {
                         let substs = substs.as_generator();
                         substs

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -219,6 +219,10 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 if tag_field == field {
                     return match layout.ty.kind() {
                         ty::Adt(def, ..) if def.is_enum() => PathElem::EnumTag,
+                        ty::Variant(ty, ..) => match ty.kind() {
+                            ty::Adt(def, ..) if def.is_enum() => PathElem::EnumTag,
+                            _ => bug!("non-variant type {:?}", layout.ty),
+                        },
                         ty::Generator(..) => PathElem::GeneratorTag,
                         _ => bug!("non-variant type {:?}", layout.ty),
                     };
@@ -272,6 +276,20 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 }
             }
 
+            ty::Variant(ty, ..) => match ty.kind() {
+                ty::Adt(def, ..) if def.is_enum() => {
+                    // we might be projecting *to* a variant, or to a field *in* a variant.
+                    match layout.variants {
+                        Variants::Single { index } => {
+                            // Inside a variant
+                            PathElem::Field(def.variants[index].fields[field].ident.name)
+                        }
+                        Variants::Multiple { .. } => bug!("we handled variants above"),
+                    }
+                }
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            },
+
             // other ADTs
             ty::Adt(def, _) => PathElem::Field(def.non_enum_variant().fields[field].ident.name),
 
@@ -567,6 +585,17 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 self.check_safe_pointer(value, "box")?;
                 Ok(true)
             }
+            ty::Variant(ty, _) => match ty.kind() {
+                ty::Adt(def, _) => {
+                    if def.is_box() {
+                        self.check_safe_pointer(value, "box")?;
+                        Ok(true)
+                    } else {
+                        Ok(false)
+                    }
+                }
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            },
             ty::FnPtr(_sig) => {
                 let value = try_validation!(
                     self.ecx.read_immediate(value),
@@ -729,6 +758,10 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
     ) -> InterpResult<'tcx> {
         let name = match old_op.layout.ty.kind() {
             ty::Adt(adt, _) => PathElem::Variant(adt.variants[variant_id].ident.name),
+            ty::Variant(ty, ..) => match ty.kind() {
+                ty::Adt(adt, ..) => PathElem::Variant(adt.variants[variant_id].ident.name),
+                _ => bug!("unexpected type {:?}", ty.kind()),
+            },
             // Generators also have variants
             ty::Generator(..) => PathElem::GeneratorState(variant_id),
             _ => bug!("Unexpected type with variant: {:?}", old_op.layout.ty),

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/combine.rs

@@ -72,6 +72,7 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     {
         let a_is_expected = relation.a_is_expected();
 
+        debug!("super_combine_tys: {:?} | {:?}", a.kind(), b.kind());
         match (a.kind(), b.kind()) {
             // Relate integral variables to other types
             (&ty::Infer(ty::IntVar(a_id)), &ty::Infer(ty::IntVar(b_id))) => {

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,16 @@ 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, _) => match ty.kind() {
+                ty::Adt(d, _) => {
+                    if d.is_enum() && d.is_payloadfree() {
+                        Some(CastTy::Int(IntTy::CEnum))
+                    } else {
+                        None
+                    }
+                }
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            }
             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,10 @@ 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, _) => match ty.kind() {
+                ty::Adt(def, _) => format!("{} `{}`", def.descr(), tcx.def_path_str(def.did)).into(),
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            }
             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 +319,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,10 @@ 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(ref ty, _) => match ty.kind() {
+            ty::Adt(def, _) => Some(AdtSimplifiedType(def.did)),
+            _ => bug!("unexpected type: {:?}", ty.kind()),
+        }
         ty::Str => Some(StrSimplifiedType),
         ty::Array(..) | ty::Slice(_) => Some(ArraySimplifiedType),
         ty::RawPtr(_) => Some(PtrSimplifiedType),

compiler/rustc_middle/src/ty/flags.rs

@@ -161,6 +161,11 @@ impl FlagComputation {
                 self.add_substs(substs);
             }
 
+            &ty::Variant(ty, _) => match ty.kind() {
+                ty::Adt(_, substs) => self.add_substs(substs),
+                _ => bug!("unexpected type: {:?}", ty.kind()),
+            }
+
             &ty::Projection(data) => {
                 self.add_flags(TypeFlags::HAS_TY_PROJECTION);
                 self.add_projection_ty(data);