Rename TypeArgs to RefinedTypeArgs

Author: coord-e

src/rty.rs

@@ -55,7 +55,7 @@ mod subtyping;
 pub use subtyping::{relate_sub_closed_type, ClauseScope, Subtyping};
 
 mod params;
-pub use params::{TypeArgs, TypeParamIdx, TypeParamSubst};
+pub use params::{RefinedTypeArgs, 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: TypeArgs<T>) -> Self {
+    pub fn new(symbol: chc::DatatypeSymbol, args: RefinedTypeArgs<T>) -> Self {
         EnumType { symbol, args }
     }
 
@@ -1372,7 +1372,7 @@ impl<FV> RefinedType<FV> {
         }
     }
 
-    pub fn instantiate_ty_params(&mut self, params: TypeArgs<FV>)
+    pub fn instantiate_ty_params(&mut self, params: RefinedTypeArgs<FV>)
     where
         FV: chc::Var,
     {

src/rty/params.rs

@@ -7,7 +7,7 @@ use rustc_index::IndexVec;
 
 use crate::chc;
 
-use super::{Closed, RefinedType};
+use super::{Closed, RefinedType, Type};
 
 rustc_index::newtype_index! {
     /// An index representing a type parameter.
@@ -53,7 +53,8 @@ impl TypeParamIdx {
     }
 }
 
-pub type TypeArgs<T> = IndexVec<TypeParamIdx, RefinedType<T>>;
+pub type RefinedTypeArgs<T = Closed> = IndexVec<TypeParamIdx, RefinedType<T>>;
+pub type TypeArgs<T = Closed> = IndexVec<TypeParamIdx, Type<T>>;
 
 /// A substitution for type parameters that maps type parameters to refinement types.
 #[derive(Debug, Clone)]
@@ -71,6 +72,16 @@ impl<T> Default for TypeParamSubst<T> {
 
 impl<T> From<TypeArgs<T>> for TypeParamSubst<T> {
     fn from(params: TypeArgs<T>) -> Self {
+        let subst = params
+            .into_iter_enumerated()
+            .map(|(idx, ty)| (idx, RefinedType::unrefined(ty)))
+            .collect();
+        Self { subst }
+    }
+}
+
+impl<T> From<RefinedTypeArgs<T>> for TypeParamSubst<T> {
+    fn from(params: RefinedTypeArgs<T>) -> Self {
         let subst = params.into_iter_enumerated().collect();
         Self { subst }
     }
@@ -112,12 +123,12 @@ impl<T> TypeParamSubst<T> {
         }
     }
 
-    pub fn into_args<F>(mut self, expected_len: usize, mut default: F) -> TypeArgs<T>
+    pub fn into_args<F>(mut self, expected_len: usize, mut default: F) -> RefinedTypeArgs<T>
     where
         T: chc::Var,
         F: FnMut(TypeParamIdx) -> RefinedType<T>,
     {
-        let mut args = TypeArgs::new();
+        let mut args = RefinedTypeArgs::new();
         for idx in 0..expected_len {
             let ty = self
                 .subst