rustc: unify Generics::{region,type}_param.

Author: eddyb

src/librustc/ty/mod.rs

@@ -939,37 +939,12 @@ impl<'a, 'gcx, 'tcx> Generics {
         }
     }
 
-    pub fn region_param(&'tcx self,
-                        param: &EarlyBoundRegion,
-                        tcx: TyCtxt<'a, 'gcx, 'tcx>)
-                        -> &'tcx GenericParamDef
-    {
-        if let Some(index) = param.index.checked_sub(self.parent_count as u32) {
-            let param = &self.params[index as usize];
-            match param.kind {
-                ty::GenericParamDefKind::Lifetime => param,
-                _ => bug!("expected lifetime parameter, but found another generic parameter")
-            }
-        } else {
-            tcx.generics_of(self.parent.expect("parent_count>0 but no parent?"))
-                .region_param(param, tcx)
-        }
-    }
-
-    /// Returns the `GenericParamDef` associated with this `ParamTy`.
-    pub fn type_param(&'tcx self,
-                      param: &ParamTy,
-                      tcx: TyCtxt<'a, 'gcx, 'tcx>)
-                      -> &'tcx GenericParamDef {
-        if let Some(index) = param.idx.checked_sub(self.parent_count as u32) {
-            let param = &self.params[index as usize];
-            match param.kind {
-                ty::GenericParamDefKind::Type {..} => param,
-                _ => bug!("expected type parameter, but found another generic parameter")
-            }
+    pub fn param_at(&'tcx self, index: u32, tcx: TyCtxt<'_, '_, 'tcx>) -> &'tcx GenericParamDef {
+        if let Some(index) = index.checked_sub(self.parent_count as u32) {
+            &self.params[index as usize]
         } else {
             tcx.generics_of(self.parent.expect("parent_count>0 but no parent?"))
-                .type_param(param, tcx)
+                .param_at(index, tcx)
         }
     }
 }

src/librustc/ty/util.rs

@@ -498,21 +498,19 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
         let result = item_substs.iter().zip(impl_substs.iter())
             .filter(|&(_, &k)| {
-                match k.unpack() {
-                    UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => {
-                        !impl_generics.region_param(ebr, self).pure_wrt_drop
-                    }
+                let index = match k.unpack() {
+                    UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) =>
+                        ebr.index,
                     UnpackedKind::Type(&ty::TyS {
                         sty: ty::Param(ref pt), ..
-                    }) => {
-                        !impl_generics.type_param(pt, self).pure_wrt_drop
-                    }
+                    }) => pt.idx,
                     UnpackedKind::Lifetime(_) | UnpackedKind::Type(_) => {
                         // not a type or region param - this should be reported
                         // as an error.
-                        false
+                        return false;
                     }
-                }
+                };
+                !impl_generics.param_at(index, self).pure_wrt_drop
             }).map(|(&item_param, _)| item_param).collect();
         debug!("destructor_constraint({:?}) = {:?}", def.did, result);
         result