make TyVid implement the Idx trait

Author: nikomatsakis

compiler/rustc_infer/src/infer/fudge.rs

@@ -187,7 +187,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for InferenceFudger<'a, 'tcx> {
                 if self.type_vars.0.contains(&vid) {
                     // This variable was created during the fudging.
                     // Recreate it with a fresh variable here.
-                    let idx = (vid.index - self.type_vars.0.start.index) as usize;
+                    let idx = vid.as_usize() - self.type_vars.0.start.as_usize();
                     let origin = self.type_vars.1[idx];
                     self.infcx.next_ty_var(origin)
                 } else {

compiler/rustc_infer/src/infer/type_variable.rs

@@ -198,15 +198,15 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     /// Note that this function does not return care whether
     /// `vid` has been unified with something else or not.
     pub fn var_diverges(&self, vid: ty::TyVid) -> Diverging {
-        self.storage.values.get(vid.index as usize).diverging
+        self.storage.values.get(vid.as_usize()).diverging
     }
 
     /// Returns the origin that was given when `vid` was created.
     ///
     /// Note that this function does not return care whether
     /// `vid` has been unified with something else or not.
     pub fn var_origin(&self, vid: ty::TyVid) -> &TypeVariableOrigin {
-        &self.storage.values.get(vid.index as usize).origin
+        &self.storage.values.get(vid.as_usize()).origin
     }
 
     /// Records that `a == b`, depending on `dir`.
@@ -271,7 +271,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         assert_eq!(eq_key.vid, sub_key);
 
         let index = self.values().push(TypeVariableData { origin, diverging });
-        assert_eq!(eq_key.vid.index, index as u32);
+        assert_eq!(eq_key.vid.as_usize(), index);
 
         debug!(
             "new_var(index={:?}, universe={:?}, diverging={:?}, origin={:?}",
@@ -359,11 +359,11 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         &mut self,
         value_count: usize,
     ) -> (Range<TyVid>, Vec<TypeVariableOrigin>) {
-        let range = TyVid { index: value_count as u32 }..TyVid { index: self.num_vars() as u32 };
+        let range = TyVid::from(value_count)..TyVid::from(self.num_vars());
         (
             range.start..range.end,
-            (range.start.index..range.end.index)
-                .map(|index| self.storage.values.get(index as usize).origin)
+            (range.start.as_usize()..range.end.as_usize())
+                .map(|index| self.storage.values.get(index).origin)
                 .collect(),
         )
     }
@@ -395,7 +395,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
                 super::UndoLog::TypeVariables(UndoLog::Values(sv::UndoLog::Other(
                     Instantiate { vid, .. },
                 ))) => {
-                    if vid.index < new_elem_threshold {
+                    if vid.as_u32() < new_elem_threshold {
                         // quick check to see if this variable was
                         // created since the snapshot started or not.
                         let mut eq_relations = ut::UnificationTable::with_log(
@@ -423,7 +423,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     pub fn unsolved_variables(&mut self) -> Vec<ty::TyVid> {
         (0..self.storage.values.len())
             .filter_map(|i| {
-                let vid = ty::TyVid { index: i as u32 };
+                let vid = ty::TyVid::from(i);
                 match self.probe(vid) {
                     TypeVariableValue::Unknown { .. } => Some(vid),
                     TypeVariableValue::Known { .. } => None,
@@ -475,10 +475,10 @@ impl<'tcx> From<ty::TyVid> for TyVidEqKey<'tcx> {
 impl<'tcx> ut::UnifyKey for TyVidEqKey<'tcx> {
     type Value = TypeVariableValue<'tcx>;
     fn index(&self) -> u32 {
-        self.vid.index
+        self.vid.as_u32()
     }
     fn from_index(i: u32) -> Self {
-        TyVidEqKey::from(ty::TyVid { index: i })
+        TyVidEqKey::from(ty::TyVid::from(i))
     }
     fn tag() -> &'static str {
         "TyVidEqKey"

compiler/rustc_middle/src/infer/unify_key.rs

@@ -20,10 +20,10 @@ pub trait ToType {
 impl UnifyKey for ty::TyVid {
     type Value = ();
     fn index(&self) -> u32 {
-        self.index
+        u32::from(*self)
     }
     fn from_index(i: u32) -> ty::TyVid {
-        ty::TyVid { index: i }
+        ty::TyVid::from(i)
     }
     fn tag() -> &'static str {
         "TyVid"

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -130,7 +130,7 @@ impl fmt::Debug for ty::FnSig<'tcx> {
 
 impl fmt::Debug for ty::TyVid {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "_#{}t", self.index)
+        write!(f, "_#{}t", u32::from(*self))
     }
 }
 

compiler/rustc_middle/src/ty/sty.rs

@@ -1489,9 +1489,10 @@ pub struct EarlyBoundRegion {
     pub name: Symbol,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)]
-pub struct TyVid {
-    pub index: u32,
+rustc_index::newtype_index! {
+    pub struct TyVid {
+        DEBUG_FORMAT = custom,
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)]

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

@@ -1157,15 +1157,15 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
             let sig = if let ty::Tuple(inputs) = inputs.kind() {
                 tcx.mk_fn_sig(
                     inputs.iter().map(|k| k.expect_ty()),
-                    tcx.mk_ty_infer(ty::TyVar(ty::TyVid { index: 0 })),
+                    tcx.mk_ty_infer(ty::TyVar(ty::TyVid::from(0_u32))),
                     false,
                     hir::Unsafety::Normal,
                     abi::Abi::Rust,
                 )
             } else {
                 tcx.mk_fn_sig(
                     std::iter::once(inputs),
-                    tcx.mk_ty_infer(ty::TyVar(ty::TyVid { index: 0 })),
+                    tcx.mk_ty_infer(ty::TyVar(ty::TyVid::from(0_u32))),
                     false,
                     hir::Unsafety::Normal,
                     abi::Abi::Rust,