rustc: rename ty_param_{name,owner} to generic_param_*.

Author: eddyb

src/librustc/infer/error_reporting/need_type_info.rs

@@ -79,7 +79,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             let ty_vars = self.type_variables.borrow();
             if let TypeVariableOrigin::TypeParameterDefinition(_, def_id) =
                 *ty_vars.var_origin(ty_vid) {
-                self.tcx.ty_param_name(def_id).to_string()
+                self.tcx.generic_param_name(def_id).to_string()
             } else {
                 ty.to_string()
             }

src/librustc/ty/mod.rs

@@ -2637,7 +2637,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
-    pub fn ty_param_name(self, id: DefId) -> InternedString {
+    pub fn generic_param_name(self, id: DefId) -> InternedString {
         let def_key = self.def_key(id);
         match def_key.disambiguated_data.data {
             DefPathData::ImplTrait => {
@@ -2688,7 +2688,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
-    pub fn ty_param_owner(self, id: DefId) -> DefId {
+    pub fn generic_param_owner(self, id: DefId) -> DefId {
         let def_key = self.def_key(id);
         match def_key.disambiguated_data.data {
             DefPathData::Trait(_) |

src/librustc/ty/query/config.rs

@@ -213,7 +213,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::erase_regions_ty<'tcx> {
 impl<'tcx> QueryDescription<'tcx> for queries::type_param_predicates<'tcx> {
     fn describe(tcx: TyCtxt, (_, def_id): (DefId, DefId)) -> String {
         format!("computing the bounds for type parameter `{}`",
-                tcx.ty_param_name(def_id))
+                tcx.generic_param_name(def_id))
     }
 }
 

src/librustc/util/ppaux.rs

@@ -1267,10 +1267,10 @@ define_print! {
 define_print! {
     () ty::ParamTy, (self, f, cx) {
         display {
-            write!(f, "{}", ty::tls::with(|tcx| tcx.ty_param_name(self.def_id)))
+            write!(f, "{}", ty::tls::with(|tcx| tcx.generic_param_name(self.def_id)))
         }
         debug {
-            write!(f, "{}/#{}", ty::tls::with(|tcx| tcx.ty_param_name(self.def_id)), self.idx)
+            write!(f, "{}/#{}", ty::tls::with(|tcx| tcx.generic_param_name(self.def_id)), self.idx)
         }
     }
 }

src/librustc_typeck/astconv.rs

@@ -1132,7 +1132,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
             traits::transitive_bounds(tcx, &bounds)
             .filter(|b| self.trait_defines_associated_type_named(b.def_id(), assoc_name));
 
-        let param_name = tcx.ty_param_name(ty_param_def_id);
+        let param_name = tcx.generic_param_name(ty_param_def_id);
         self.one_bound_for_assoc_type(suitable_bounds,
                                       &param_name.as_str(),
                                       assoc_name,
@@ -1406,7 +1406,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
                 assert_eq!(opt_self_ty, None);
                 self.prohibit_generics(&path.segments);
 
-                let param_owner_def_id = tcx.ty_param_owner(did);
+                let param_owner_def_id = tcx.generic_param_owner(did);
                 let generics = tcx.generics_of(param_owner_def_id);
                 let index = generics.param_def_id_to_index[&did];
                 tcx.mk_ty_param(generics.param_at(index, tcx))

src/librustc_typeck/check/mod.rs

@@ -1825,7 +1825,7 @@ impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
                                  -> ty::GenericPredicates<'tcx>
     {
         let tcx = self.tcx;
-        let item_def_id = tcx.ty_param_owner(def_id);
+        let item_def_id = tcx.generic_param_owner(def_id);
         let generics = tcx.generics_of(item_def_id);
         let index = generics.param_def_id_to_index[&def_id];
         ty::GenericPredicates {

src/librustc_typeck/collect.rs

@@ -244,7 +244,7 @@ fn type_param_predicates<'a, 'tcx>(
     // written inline like `<T:Foo>` or in a where clause like
     // `where T:Foo`.
 
-    let param_owner_def_id = tcx.ty_param_owner(def_id);
+    let param_owner_def_id = tcx.generic_param_owner(def_id);
     let generics = tcx.generics_of(param_owner_def_id);
     let index = generics.param_def_id_to_index[&def_id];
     let ty = tcx.mk_ty_param(generics.param_at(index, tcx));