Pass only GenericArgs to def_ty_with_args

Author: coord-e

src/analyze.rs

@@ -241,16 +241,16 @@ impl<'tcx> Analyzer<'tcx> {
     pub fn def_ty_with_args(
         &mut self,
         def_id: DefId,
-        rty_args: rty::TypeArgs,
         generic_args: mir_ty::GenericArgsRef<'tcx>,
     ) -> Option<rty::RefinedType> {
+        let type_builder = TypeBuilder::new(self.tcx, def_id);
         let deferred_ty = match self.defs.get(&def_id)? {
             DefTy::Concrete(rty) => {
                 let mut def_ty = rty.clone();
                 def_ty.instantiate_ty_params(
-                    rty_args
-                        .clone()
-                        .into_iter()
+                    generic_args
+                        .types()
+                        .map(|ty| type_builder.build(ty))
                         .map(rty::RefinedType::unrefined)
                         .collect(),
                 );
@@ -264,7 +264,6 @@ impl<'tcx> Analyzer<'tcx> {
             return Some(rty.clone());
         }
 
-        let type_builder = TypeBuilder::new(self.tcx, def_id);
         let mut analyzer = self.local_def_analyzer(def_id.as_local()?);
         analyzer
             .type_builder(type_builder)

src/analyze/basic_block.rs

@@ -407,15 +407,12 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
                 _ty,
             ) => {
                 let func_ty = match operand.const_fn_def() {
-                    Some((def_id, args)) => {
-                        let rty_args: IndexVec<_, _> =
-                            args.types().map(|ty| self.type_builder.build(ty)).collect();
-                        self.ctx
-                            .def_ty_with_args(def_id, rty_args, args)
-                            .expect("unknown def")
-                            .ty
-                            .clone()
-                    }
+                    Some((def_id, args)) => self
+                        .ctx
+                        .def_ty_with_args(def_id, args)
+                        .expect("unknown def")
+                        .ty
+                        .clone(),
                     _ => unimplemented!(),
                 };
                 PlaceType::with_ty_and_term(func_ty.vacuous(), chc::Term::null())
@@ -628,9 +625,8 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
                     tracing::info!(?def_id, ?resolved_def_id, "resolve",);
                 }
 
-                let rty_args = args.types().map(|ty| self.type_builder.build(ty)).collect();
                 self.ctx
-                    .def_ty_with_args(resolved_def_id, rty_args, args)
+                    .def_ty_with_args(resolved_def_id, args)
                     .expect("unknown def")
                     .ty
                     .vacuous()

src/rty.rs

@@ -55,7 +55,7 @@ mod subtyping;
 pub use subtyping::{relate_sub_closed_type, ClauseScope, Subtyping};
 
 mod params;
-pub use params::{RefinedTypeArgs, TypeArgs, TypeParamIdx, TypeParamSubst};
+pub use params::{RefinedTypeArgs, TypeParamIdx, TypeParamSubst};
 
 rustc_index::newtype_index! {
     /// An index representing function parameter.