Rename TypeParams to TypeArgs

Author: coord-e

src/analyze/basic_block.rs

@@ -219,7 +219,7 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
                             .into_iter()
                             .map(|ty| rty::RefinedType::unrefined(ty.vacuous()));
 
-                        let params: IndexVec<_, _> = args
+                        let rty_args: IndexVec<_, _> = args
                             .types()
                             .map(|ty| {
                                 self.ctx
@@ -230,15 +230,15 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
                         for (field_pty, mut variant_rty) in
                             field_tys.clone().into_iter().zip(variant_rtys)
                         {
-                            variant_rty.instantiate_ty_params(params.clone());
+                            variant_rty.instantiate_ty_params(rty_args.clone());
                             let cs = self
                                 .env
                                 .relate_sub_refined_type(&field_pty.into(), &variant_rty.boxed());
                             self.ctx.extend_clauses(cs);
                         }
 
-                        let sort_args: Vec<_> = params.iter().map(|rty| rty.ty.to_sort()).collect();
-                        let ty = rty::EnumType::new(ty_sym.clone(), params).into();
+                        let sort_args: Vec<_> = rty_args.iter().map(|rty| rty.ty.to_sort()).collect();
+                        let ty = rty::EnumType::new(ty_sym.clone(), rty_args).into();
 
                         let mut builder = PlaceTypeBuilder::default();
                         let mut field_terms = Vec::new();

src/refine/env.rs

@@ -930,7 +930,7 @@ impl Env {
                         .field_tys()
                         .map(|ty| rty::RefinedType::unrefined(ty.clone().vacuous()).boxed());
                     let got_tys = field_tys.iter().map(|ty| ty.clone().into());
-                    rty::unify_tys_params(expected_tys, got_tys).into_params(def.ty_params, |_| {
+                    rty::unify_tys_params(expected_tys, got_tys).into_args(def.ty_params, |_| {
                         panic!("var_type: should unify all params")
                     })
                 };

src/rty.rs

@@ -55,7 +55,7 @@ mod subtyping;
 pub use subtyping::{relate_sub_closed_type, ClauseScope, Subtyping};
 
 mod params;
-pub use params::{TypeParamIdx, TypeParamSubst, TypeParams};
+pub use params::{TypeArgs, TypeParamIdx, TypeParamSubst};
 
 rustc_index::newtype_index! {
     /// An index representing function parameter.
@@ -487,7 +487,7 @@ where
 }
 
 impl<T> EnumType<T> {
-    pub fn new(symbol: chc::DatatypeSymbol, args: TypeParams<T>) -> Self {
+    pub fn new(symbol: chc::DatatypeSymbol, args: TypeArgs<T>) -> Self {
         EnumType { symbol, args }
     }
 
@@ -1372,7 +1372,7 @@ impl<FV> RefinedType<FV> {
         }
     }
 
-    pub fn instantiate_ty_params(&mut self, params: TypeParams<FV>)
+    pub fn instantiate_ty_params(&mut self, params: TypeArgs<FV>)
     where
         FV: chc::Var,
     {

src/rty/params.rs

@@ -39,7 +39,7 @@ impl TypeParamIdx {
     }
 }
 
-pub type TypeParams<T> = IndexVec<TypeParamIdx, RefinedType<T>>;
+pub type TypeArgs<T> = IndexVec<TypeParamIdx, RefinedType<T>>;
 
 /// A substitution for type parameters that maps type parameters to refinement types.
 #[derive(Debug, Clone)]
@@ -55,8 +55,8 @@ impl<T> Default for TypeParamSubst<T> {
     }
 }
 
-impl<T> From<TypeParams<T>> for TypeParamSubst<T> {
-    fn from(params: TypeParams<T>) -> Self {
+impl<T> From<TypeArgs<T>> for TypeParamSubst<T> {
+    fn from(params: TypeArgs<T>) -> Self {
         let subst = params.into_iter_enumerated().collect();
         Self { subst }
     }
@@ -98,20 +98,20 @@ impl<T> TypeParamSubst<T> {
         }
     }
 
-    pub fn into_params<F>(mut self, expected_len: usize, mut default: F) -> TypeParams<T>
+    pub fn into_args<F>(mut self, expected_len: usize, mut default: F) -> TypeArgs<T>
     where
         T: chc::Var,
         F: FnMut(TypeParamIdx) -> RefinedType<T>,
     {
-        let mut params = TypeParams::new();
+        let mut args = TypeArgs::new();
         for idx in 0..expected_len {
             let ty = self
                 .subst
                 .remove(&idx.into())
                 .unwrap_or_else(|| default(idx.into()));
-            params.push(ty);
+            args.push(ty);
         }
-        params
+        args
     }
 
     pub fn strip_refinement(self) -> TypeParamSubst<Closed> {