add ty::Variant type

Author: zhamlin

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -373,6 +373,8 @@ 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/validity.rs

@@ -612,6 +612,7 @@ 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(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

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

@@ -406,6 +406,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
                     t
                 }
             }
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

compiler/rustc_infer/src/infer/freshen.rs

@@ -218,6 +218,8 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
             | ty::Opaque(..) => t.super_fold_with(self),
 
             ty::Placeholder(..) | ty::Bound(..) => bug!("unexpected type {:?}", t),
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

compiler/rustc_infer/src/infer/outlives/components.rs

@@ -187,6 +187,7 @@ fn compute_components(
                 // themselves can be readily identified.
                 compute_components_recursive(tcx, ty.into(), out, visited);
             }
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
 }
 

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

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

compiler/rustc_middle/src/ty/error.rs

@@ -247,6 +247,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() {
@@ -318,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

@@ -104,6 +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)"),
     }
 }
 

compiler/rustc_middle/src/ty/flags.rs

@@ -213,6 +213,8 @@ impl FlagComputation {
                 computation.add_tys(fn_sig.inputs());
                 computation.add_ty(fn_sig.output());
             }),
+
+            &ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

compiler/rustc_middle/src/ty/layout.rs

@@ -1403,6 +1403,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             ty::Bound(..) | ty::Param(_) | ty::Error(_) => {
                 return Err(LayoutError::Unknown(ty));
             }
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         })
     }
 }
@@ -2388,6 +2389,7 @@ where
                 | ty::Param(_)
                 | ty::Infer(_)
                 | ty::Error(_) => bug!("TyAndLayout::field: unexpected type `{}`", this.ty),
+                ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
             }
         }
 

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

@@ -315,6 +315,8 @@ 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

@@ -605,6 +605,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/structural_impls.rs

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

compiler/rustc_middle/src/ty/sty.rs

@@ -195,6 +195,9 @@ pub enum TyKind<'tcx> {
     /// A type variable used during type checking.
     Infer(InferTy),
 
+    /// Type of a variant of an enum
+    Variant(Ty<'tcx>, VariantIdx),
+
     /// A placeholder for a type which could not be computed; this is
     /// propagated to avoid useless error messages.
     Error(DelaySpanBugEmitted),
@@ -2059,6 +2062,8 @@ impl<'tcx> TyS<'tcx> {
             | ty::Infer(FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 bug!("`discriminant_ty` applied to unexpected type: {:?}", self)
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -2107,6 +2112,8 @@ impl<'tcx> TyS<'tcx> {
             | ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 bug!("`ptr_metadata_ty` applied to unexpected type: {:?}", tail)
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -2185,6 +2192,8 @@ impl<'tcx> TyS<'tcx> {
             | ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 bug!("`is_trivially_sized` applied to unexpected type: {:?}", self)
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 }

compiler/rustc_middle/src/ty/util.rs

@@ -712,6 +712,7 @@ impl<'tcx> ty::TyS<'tcx> {
             | ty::Param(_)
             | ty::Placeholder(_)
             | ty::Projection(_) => false,
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -752,6 +753,7 @@ impl<'tcx> ty::TyS<'tcx> {
             | ty::Param(_)
             | ty::Placeholder(_)
             | ty::Projection(_) => false,
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -874,6 +876,8 @@ impl<'tcx> ty::TyS<'tcx> {
             Projection(_) | Opaque(..) | Param(_) | Bound(..) | Placeholder(_) | Infer(_) => false,
 
             Foreign(_) | GeneratorWitness(..) | Error(_) => false,
+
+            Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -1022,6 +1026,7 @@ pub fn needs_drop_components(
         | ty::Infer(_)
         | ty::Closure(..)
         | ty::Generator(..) => Ok(smallvec![ty]),
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 }
 

compiler/rustc_middle/src/ty/walk.rs

@@ -198,6 +198,7 @@ fn push_inner<'tcx>(
                 stack.push(sig.skip_binder().output().into());
                 stack.extend(sig.skip_binder().inputs().iter().copied().rev().map(|ty| ty.into()));
             }
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         },
         GenericArgKind::Lifetime(_) => {}
         GenericArgKind::Const(parent_ct) => {

compiler/rustc_privacy/src/lib.rs

@@ -277,6 +277,7 @@ where
             ty::Bound(..) | ty::Placeholder(..) | ty::Infer(..) => {
                 bug!("unexpected type: {:?}", ty)
             }
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
 
         if self.def_id_visitor.shallow() {

compiler/rustc_symbol_mangling/src/v0.rs

@@ -467,6 +467,8 @@ impl Printer<'tcx> for &mut SymbolMangler<'tcx> {
             }
 
             ty::GeneratorWitness(_) => bug!("symbol_names: unexpected `GeneratorWitness`"),
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
 
         // Only cache types that do not refer to an enclosing

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -651,5 +651,7 @@ fn ty_is_local_constructor(ty: Ty<'_>, in_crate: InCrate) -> bool {
         ty::Generator(..) | ty::GeneratorWitness(..) => {
             bug!("ty_is_local invoked on unexpected type: {:?}", ty)
         }
+
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 }

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

@@ -1377,6 +1377,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                 ty::Foreign(..) => Some(19),
                 ty::GeneratorWitness(..) => Some(20),
                 ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) | ty::Error(_) => None,
+                ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
             }
         }
 

compiler/rustc_trait_selection/src/traits/project.rs

@@ -1402,6 +1402,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     | ty::Placeholder(..)
                     | ty::Infer(..)
                     | ty::Error(_) => false,
+                    ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
                 }
             }
             super::ImplSource::Pointee(..) => {
@@ -1447,6 +1448,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     | ty::Placeholder(..)
                     | ty::Infer(..)
                     | ty::Error(_) => false,
+                    ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
                 }
             }
             super::ImplSource::Param(..) => {

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

@@ -135,5 +135,6 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         | ty::Infer(_)
         | ty::Bound(..)
         | ty::Generator(..) => false,
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 }

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

@@ -1021,6 +1021,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                     debug!("not returning");
                 }
+                ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
             }
             debug!(?stack, "assemble_const_drop_candidates - in loop");
         }

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

@@ -1835,6 +1835,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -1912,6 +1914,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 
@@ -1993,6 +1997,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 // the auto trait bounds in question.
                 t.rebind(vec![self.tcx().type_of(def_id).subst(self.tcx(), substs)])
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
     }
 

compiler/rustc_trait_selection/src/traits/structural_match.rs

@@ -210,6 +210,8 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for Search<'a, 'tcx> {
                 // as this may still emit relevant errors.
                 return ControlFlow::CONTINUE;
             }
+
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         };
 
         if !self.seen.insert(adt_def.did) {

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -687,6 +687,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
                         self.compute(ty.into());
                     }
                 }
+                ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
             }
         }
     }

compiler/rustc_traits/src/chalk/lowering.rs

@@ -330,6 +330,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Ty<RustInterner<'tcx>>> for Ty<'tcx> {
             }
             ty::Infer(_infer) => unimplemented!(),
             ty::Error(_) => chalk_ir::TyKind::Error,
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         }
         .intern(interner)
     }

compiler/rustc_traits/src/dropck_outlives.rs

@@ -299,6 +299,8 @@ fn dtorck_constraint_for_ty<'tcx>(
             // be fully resolved.
             return Err(NoSolution);
         }
+
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     }
 
     Ok(())

compiler/rustc_ty_utils/src/ty.rs

@@ -68,6 +68,8 @@ fn sized_constraint_for_ty<'tcx>(
         Placeholder(..) | Bound(..) | Infer(..) => {
             bug!("unexpected type `{:?}` in sized_constraint_for_ty", ty)
         }
+
+        ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
     };
     debug!("sized_constraint_for_ty({:?}) = {:?}", ty, result);
     result

compiler/rustc_typeck/src/check/cast.rs

@@ -144,6 +144,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .delay_span_bug(span, &format!("`{:?}` should be sized but is not?", t));
                 return Err(ErrorReported);
             }
+            ty::Variant(..) => unimplemented!("TODO(zhamlin)"),
         })
     }
 }