diff --git a/checker/src/block_visitor.rs b/checker/src/block_visitor.rs
index ffa2cb6a..a7872a4b 100644
--- a/checker/src/block_visitor.rs
+++ b/checker/src/block_visitor.rs
@@ -17,10 +17,10 @@ use rustc_middle::mir;
 use rustc_middle::mir::interpret::{alloc_range, ConstValue, GlobalAlloc, Scalar};
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::LayoutCx;
-use rustc_middle::ty::subst::{GenericArg, SubstsRef};
 use rustc_middle::ty::{
     Const, FloatTy, IntTy, ParamConst, ScalarInt, Ty, TyKind, UintTy, ValTree, VariantDef,
 };
+use rustc_middle::ty::{GenericArg, GenericArgsRef};
 use rustc_target::abi::{FieldIdx, Primitive, TagEncoding, VariantIdx, Variants};
 
 use crate::abstract_value;
@@ -497,12 +497,12 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
         self.type_visitor_mut()
             .set_path_rustc_type(path.clone(), ty);
 
-        if let TyKind::Adt(def, substs) = ty.kind() {
+        if let TyKind::Adt(def, args) = ty.kind() {
             if let Some(destructor) = tcx.adt_destructor(def.did()) {
                 let actual_argument_types = vec![Ty::new_mut_ref(tcx, tcx.lifetimes.re_static, ty)];
                 let callee_generic_arguments = self
                     .type_visitor()
-                    .specialize_substs(substs, &self.type_visitor().generic_argument_map);
+                    .specialize_generic_args(args, &self.type_visitor().generic_argument_map);
                 let callee_generic_argument_map = self.type_visitor().get_generic_arguments_map(
                     def.did(),
                     callee_generic_arguments,
@@ -510,7 +510,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                 );
                 let fun_ty = tcx.type_of(destructor.did).skip_binder();
                 let func_const = self
-                    .visit_function_reference(destructor.did, fun_ty, Some(substs))
+                    .visit_function_reference(destructor.did, fun_ty, Some(args))
                     .clone();
                 let func_to_call = Rc::new(func_const.clone().into());
                 let ref_to_path_value = AbstractValue::make_reference(path.clone());
@@ -632,15 +632,15 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
         let callee_def_id = func_ref_to_call
             .def_id
             .expect("callee obtained via operand should have def id");
-        let substs = self
+        let generic_args = self
             .bv
             .cv
-            .substs_cache
+            .generic_args_cache
             .get(&callee_def_id)
             .expect("MIR should ensure this");
         let mut callee_generic_arguments = self
             .type_visitor()
-            .specialize_substs(substs, &self.type_visitor().generic_argument_map);
+            .specialize_generic_args(generic_args, &self.type_visitor().generic_argument_map);
         let actual_args: Vec<(Rc<Path>, Rc<AbstractValue>)> = args
             .iter()
             .map(|arg| (self.get_operand_path(arg), self.visit_operand(arg)))
@@ -677,8 +677,8 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
         // might not be specialized enough.
         if !actual_argument_types.is_empty() && !utils::are_concrete(callee_generic_arguments) {
             let fty = self.bv.tcx.type_of(callee_def_id).skip_binder();
-            if let TyKind::FnDef(_, substs) = fty.kind() {
-                for (i, generic_ty_arg) in substs.types().enumerate() {
+            if let TyKind::FnDef(_, args) = fty.kind() {
+                for (i, generic_ty_arg) in args.types().enumerate() {
                     if let TyKind::Param(t_par) = generic_ty_arg.kind() {
                         if t_par.name.as_str() == "Self" {
                             let mut gen_args: Vec<GenericArg<'_>> =
@@ -687,7 +687,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                                 .type_visitor()
                                 .get_dereferenced_type(actual_argument_types[0])
                                 .into();
-                            callee_generic_arguments = self.bv.tcx.mk_substs(&gen_args);
+                            callee_generic_arguments = self.bv.tcx.mk_args(&gen_args);
                             break;
                         }
                     }
@@ -1011,29 +1011,29 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                     );
                 if let TyKind::Alias(
                     rustc_middle::ty::Opaque,
-                    rustc_middle::ty::AliasTy { def_id, substs, .. },
+                    rustc_middle::ty::AliasTy { def_id, args, .. },
                 ) = specialized_closure_ty.kind()
                 {
-                    let substs = self
+                    let args = self
                         .type_visitor()
-                        .specialize_substs(substs, &self.type_visitor().generic_argument_map);
-                    self.bv.cv.substs_cache.insert(*def_id, substs);
+                        .specialize_generic_args(args, &self.type_visitor().generic_argument_map);
+                    self.bv.cv.generic_args_cache.insert(*def_id, args);
                     let closure_ty = self.bv.tcx.type_of(*def_id).skip_binder();
                     let map = self
                         .type_visitor()
-                        .get_generic_arguments_map(*def_id, substs, &[]);
+                        .get_generic_arguments_map(*def_id, args, &[]);
                     specialized_closure_ty = self
                         .type_visitor()
                         .specialize_generic_argument_type(closure_ty, &map);
                 }
                 match specialized_closure_ty.kind() {
-                    TyKind::Closure(def_id, substs)
-                    | TyKind::Generator(def_id, substs, _)
-                    | TyKind::FnDef(def_id, substs) => {
+                    TyKind::Closure(def_id, args)
+                    | TyKind::Generator(def_id, args, _)
+                    | TyKind::FnDef(def_id, args) => {
                         return extract_func_ref(self.visit_function_reference(
                             *def_id,
                             specialized_closure_ty,
-                            Some(substs),
+                            Some(args),
                         ));
                     }
                     TyKind::Ref(_, ty, _) => {
@@ -1042,13 +1042,13 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                                 *ty,
                                 &self.type_visitor().generic_argument_map,
                             );
-                        if let TyKind::Closure(def_id, substs) | TyKind::FnDef(def_id, substs) =
+                        if let TyKind::Closure(def_id, args) | TyKind::FnDef(def_id, args) =
                             specialized_closure_ty.kind()
                         {
                             return extract_func_ref(self.visit_function_reference(
                                 *def_id,
                                 specialized_closure_ty,
-                                Some(substs),
+                                Some(args),
                             ));
                         }
                         if let TyKind::Dynamic(..) = specialized_closure_ty.kind() {
@@ -2537,7 +2537,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                     self.visit_use(index_path, operand);
                 }
             }
-            mir::AggregateKind::Adt(def, variant_idx, substs, _, case_index) => {
+            mir::AggregateKind::Adt(def, variant_idx, args, _, case_index) => {
                 let mut path = path;
                 let adt_def = self.bv.tcx.adt_def(def);
                 let variant_def = &adt_def.variants()[*variant_idx];
@@ -2566,7 +2566,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                     let case_index = case_index.unwrap_or(0usize.into());
                     let field_path = Path::new_union_field(path, case_index.into(), num_cases);
                     let field = &variant_def.fields[case_index];
-                    let field_ty = field.ty(self.bv.tcx, substs);
+                    let field_ty = field.ty(self.bv.tcx, args);
                     self.type_visitor_mut()
                         .set_path_rustc_type(field_path.clone(), field_ty);
                     self.visit_use(field_path, &operands[0usize.into()]);
@@ -2578,7 +2578,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                 }
                 for (i, field) in variant_def.fields.iter().enumerate() {
                     let field_path = Path::new_field(path.clone(), i);
-                    let field_ty = field.ty(self.bv.tcx, substs);
+                    let field_ty = field.ty(self.bv.tcx, args);
                     self.type_visitor_mut()
                         .set_path_rustc_type(field_path.clone(), field_ty);
                     if let Some(operand) = operands.get(i.into()) {
@@ -2591,10 +2591,10 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                     }
                 }
             }
-            mir::AggregateKind::Closure(def_id, substs)
-            | mir::AggregateKind::Generator(def_id, substs, _) => {
+            mir::AggregateKind::Closure(def_id, args)
+            | mir::AggregateKind::Generator(def_id, args, _) => {
                 let ty = self.bv.tcx.type_of(*def_id).skip_binder();
-                let func_const = self.visit_function_reference(*def_id, ty, Some(substs));
+                let func_const = self.visit_function_reference(*def_id, ty, Some(args));
                 let func_val = Rc::new(func_const.clone().into());
                 self.bv.update_value_at(path.clone(), func_val);
                 for (i, operand) in operands.iter().enumerate() {
@@ -2713,23 +2713,22 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
     ) -> Rc<AbstractValue> {
         let mut def_id = unevaluated.def;
         let def_ty = self.bv.cv.tcx.type_of(def_id);
-        let substs = self.type_visitor().specialize_substs(
-            unevaluated.substs,
-            &self.type_visitor().generic_argument_map,
-        );
-        self.bv.cv.substs_cache.insert(def_id, substs);
+        let args = self
+            .type_visitor()
+            .specialize_generic_args(unevaluated.args, &self.type_visitor().generic_argument_map);
+        self.bv.cv.generic_args_cache.insert(def_id, args);
         let path = match unevaluated.promoted {
             Some(promoted) => {
                 let index = promoted.index();
                 Rc::new(PathEnum::PromotedConstant { ordinal: index }.into())
             }
             None => {
-                if !substs.is_empty() {
+                if !args.is_empty() {
                     let param_env = rustc_middle::ty::ParamEnv::reveal_all();
                     trace!("devirtualize resolving def_id {:?}: {:?}", def_id, def_ty);
-                    trace!("substs {:?}", substs);
+                    trace!("args {:?}", args);
                     if let Ok(Some(instance)) =
-                        rustc_middle::ty::Instance::resolve(self.bv.tcx, param_env, def_id, substs)
+                        rustc_middle::ty::Instance::resolve(self.bv.tcx, param_env, def_id, args)
                     {
                         def_id = instance.def.def_id();
                         trace!("resolved it to {:?}", def_id);
@@ -2740,7 +2739,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                 } else if self.bv.cv.known_names_cache.get(self.bv.tcx, def_id)
                     == KnownNames::AllocRawVecMinNonZeroCap
                 {
-                    if let Ok(ty_and_layout) = self.type_visitor().layout_of(substs.type_at(0)) {
+                    if let Ok(ty_and_layout) = self.type_visitor().layout_of(args.type_at(0)) {
                         if !ty_and_layout.is_unsized() {
                             let size_of_t = ty_and_layout.layout.size().bytes();
                             let min_non_zero_cap: u128 = if size_of_t == 1 {
@@ -2844,14 +2843,14 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
 
     fn deserialize_fields(
         &mut self,
-        substs: SubstsRef<'tcx>,
+        args: GenericArgsRef<'tcx>,
         mut val_tree_iter: std::slice::Iter<ValTree<'tcx>>,
         heap_path: Rc<Path>,
         variant: &VariantDef,
     ) {
         for (i, field) in variant.fields.iter().enumerate() {
             let field_path = Path::new_field(heap_path.clone(), i);
-            let field_ty = field.ty(self.bv.tcx, substs);
+            let field_ty = field.ty(self.bv.tcx, args);
             if let Some(val_tree) = val_tree_iter.next() {
                 self.deserialize_val_tree(val_tree, field_path, field_ty);
             } else {
@@ -2873,7 +2872,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                 self.bv.update_value_at(target_path, const_value);
             }
             ValTree::Branch(val_trees) => match ty.kind() {
-                TyKind::Adt(def, substs) if def.is_enum() => {
+                TyKind::Adt(def, args) if def.is_enum() => {
                     let mut val_tree_iter = val_trees.iter();
                     let variant_index =
                         if let Some(ValTree::Leaf(scalar_int)) = val_tree_iter.next() {
@@ -2885,15 +2884,15 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                             );
                         };
                     let variant = &def.variants()[variant_index];
-                    self.deserialize_fields(substs, val_tree_iter, target_path, variant);
+                    self.deserialize_fields(args, val_tree_iter, target_path, variant);
                 }
                 TyKind::Adt(def, _) if def.is_union() => {
                     debug!("Did not expect to a serialized union value {:?}", def);
                 }
-                TyKind::Adt(def, substs) => {
+                TyKind::Adt(def, args) => {
                     let val_tree_iter = val_trees.iter();
                     let variant = &def.variants()[VariantIdx::new(0)];
-                    self.deserialize_fields(substs, val_tree_iter, target_path, variant);
+                    self.deserialize_fields(args, val_tree_iter, target_path, variant);
                 }
                 TyKind::Tuple(types) => {
                     let mut val_tree_iter = val_trees.iter();
@@ -3008,12 +3007,12 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                     }
                     Some(GlobalAlloc::Function(instance)) => {
                         let def_id = instance.def.def_id();
-                        let substs = self.type_visitor().specialize_substs(
-                            instance.substs,
+                        let args = self.type_visitor().specialize_generic_args(
+                            instance.args,
                             &self.type_visitor().generic_argument_map,
                         );
                         let fn_ty = self.bv.tcx.type_of(def_id).skip_binder();
-                        self.bv.cv.substs_cache.insert(def_id, substs);
+                        self.bv.cv.generic_args_cache.insert(def_id, args);
                         let fun_val = Rc::new(
                             self.bv
                                 .cv
@@ -3021,7 +3020,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                                 .get_function_constant_for(
                                     def_id,
                                     fn_ty,
-                                    Some(substs),
+                                    Some(args),
                                     self.bv.tcx,
                                     &mut self.bv.cv.known_names_cache,
                                     &mut self.bv.cv.summary_cache,
@@ -3164,8 +3163,8 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
         self.type_visitor_mut()
             .set_path_rustc_type(target_path.clone(), ty);
         match ty.kind() {
-            TyKind::Adt(def, substs) if def.is_enum() => {
-                trace!("deserializing {:?} {:?}", def, substs);
+            TyKind::Adt(def, args) if def.is_enum() => {
+                trace!("deserializing {:?} {:?}", def, args);
                 trace!("def.repr() {:?}", def.repr());
                 let mut bytes_left_to_deserialize = bytes;
                 if let Ok(enum_ty_layout) = self.type_visitor().layout_of(ty) {
@@ -3210,7 +3209,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                             trace!("deserializing field({}) {:?}", i, field);
                             trace!("bytes_left_deserialize {:?}", bytes_left_to_deserialize);
                             let field_path = Path::new_field(target_path.clone(), i);
-                            let field_ty = field.ty(self.bv.tcx, substs);
+                            let field_ty = field.ty(self.bv.tcx, args);
                             trace!(
                                 "field ty layout {:?}",
                                 self.type_visitor().layout_of(field_ty)
@@ -3225,8 +3224,8 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                 }
                 bytes_left_to_deserialize
             }
-            TyKind::Adt(def, substs) => {
-                trace!("deserializing {:?} {:?}", def, substs);
+            TyKind::Adt(def, args) => {
+                trace!("deserializing {:?} {:?}", def, args);
                 let mut bytes_left_to_deserialize = bytes;
                 for variant in def.variants().iter() {
                     trace!("deserializing variant {:?}", variant);
@@ -3235,7 +3234,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                         trace!("deserializing field({}) {:?}", i, field);
                         trace!("bytes_left_deserialize {:?}", bytes_left_to_deserialize);
                         let field_path = Path::new_field(target_path.clone(), i);
-                        let field_ty = field.ty(self.bv.tcx, substs);
+                        let field_ty = field.ty(self.bv.tcx, args);
                         trace!(
                             "field ty layout {:?}",
                             self.type_visitor().layout_of(field_ty)
@@ -3412,22 +3411,22 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
             }
             // todo: bytes is the serialization of the captured state of a closure/generator
             // deserialize that and return an heap block that represents the closure state + func ptr
-            TyKind::Closure(def_id, substs)
-            | TyKind::FnDef(def_id, substs)
-            | TyKind::Generator(def_id, substs, ..)
+            TyKind::Closure(def_id, args)
+            | TyKind::FnDef(def_id, args)
+            | TyKind::Generator(def_id, args, ..)
             | TyKind::Alias(
                 rustc_middle::ty::Opaque,
-                rustc_middle::ty::AliasTy { def_id, substs, .. },
+                rustc_middle::ty::AliasTy { def_id, args, .. },
             ) => {
                 let specialized_ty = self.type_visitor().specialize_generic_argument_type(
                     ty,
                     &self.type_visitor().generic_argument_map,
                 );
-                let substs = self
+                let specialized_args = self
                     .type_visitor()
-                    .specialize_substs(substs, &self.type_visitor().generic_argument_map);
+                    .specialize_generic_args(args, &self.type_visitor().generic_argument_map);
                 let func_val = Rc::new(
-                    self.visit_function_reference(*def_id, specialized_ty, Some(substs))
+                    self.visit_function_reference(*def_id, specialized_ty, Some(specialized_args))
                         .clone()
                         .into(),
                 );
@@ -3615,9 +3614,9 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                             TyKind::Adt(adt_def, _) => adt_def
                                 .discriminants(self.bv.tcx)
                                 .find(|(_, var)| var.val == data),
-                            TyKind::Generator(def_id, substs, _) => {
-                                let substs = substs.as_generator();
-                                substs
+                            TyKind::Generator(def_id, args, _) => {
+                                let generator = args.as_generator();
+                                generator
                                     .discriminants(*def_id, self.bv.tcx)
                                     .find(|(_, var)| var.val == data)
                             }
@@ -3716,39 +3715,43 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                 }
                 TyKind::Uint(..) => self.bv.cv.constant_value_cache.get_u128_for(data),
                 TyKind::RawPtr(..) => self.bv.cv.constant_value_cache.get_u128_for(data),
-                TyKind::Closure(def_id, substs) => {
+                TyKind::Closure(def_id, args) => {
                     let specialized_ty = self.type_visitor().specialize_generic_argument_type(
                         ty,
                         &self.type_visitor().generic_argument_map,
                     );
-                    let substs = self
+                    let specialized_args = self
                         .type_visitor()
-                        .specialize_substs(substs, &self.type_visitor().generic_argument_map);
-                    if substs.len() >= 3 {
-                        let tuple_ty = substs.last().unwrap().expect_ty();
+                        .specialize_generic_args(args, &self.type_visitor().generic_argument_map);
+                    if specialized_args.len() >= 3 {
+                        let tuple_ty = specialized_args.last().unwrap().expect_ty();
                         let cv = self.get_constant_value_from_scalar(tuple_ty, data, size);
                         let cp = Path::get_as_path(cv);
                         let fr = self
-                            .visit_function_reference(*def_id, specialized_ty, Some(substs))
+                            .visit_function_reference(
+                                *def_id,
+                                specialized_ty,
+                                Some(specialized_args),
+                            )
                             .clone();
                         let fv = Rc::<AbstractValue>::new(fr.into());
                         let fp = Path::get_as_path(fv.clone());
                         self.bv.copy_or_move_elements(fp, cp, tuple_ty, true);
                         return fv;
                     } else {
-                        unreachable!("substs for closure not right {:?}", substs);
+                        unreachable!("args for closure not right {:?}", specialized_args);
                     }
                 }
-                TyKind::FnDef(def_id, substs) => {
+                TyKind::FnDef(def_id, args) => {
                     debug_assert!(size == 0 && data == 0);
                     let specialized_ty = self.type_visitor().specialize_generic_argument_type(
                         ty,
                         &self.type_visitor().generic_argument_map,
                     );
-                    let substs = self
+                    let specialized_args = self
                         .type_visitor()
-                        .specialize_substs(substs, &self.type_visitor().generic_argument_map);
-                    self.visit_function_reference(*def_id, specialized_ty, Some(substs))
+                        .specialize_generic_args(args, &self.type_visitor().generic_argument_map);
+                    self.visit_function_reference(*def_id, specialized_ty, Some(specialized_args))
                 }
                 _ => {
                     let bytes = &data.to_ne_bytes()[0..size];
@@ -3791,11 +3794,11 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
         &mut self,
         def_id: DefId,
         ty: Ty<'tcx>,
-        generic_args: Option<SubstsRef<'tcx>>,
+        generic_args: Option<GenericArgsRef<'tcx>>,
     ) -> &ConstantDomain {
         //todo: is def_id unique enough? Perhaps add ty?
         if let Some(generic_args) = generic_args {
-            self.bv.cv.substs_cache.insert(def_id, generic_args);
+            self.bv.cv.generic_args_cache.insert(def_id, generic_args);
         }
         self.bv.cv.constant_value_cache.get_function_constant_for(
             def_id,
@@ -3935,7 +3938,7 @@ impl<'block, 'analysis, 'compilation, 'tcx> BlockVisitor<'block, 'analysis, 'com
                     let func_const = self.visit_function_reference(
                         *def_id,
                         ty,
-                        Some(generic_args.as_closure().substs),
+                        Some(generic_args.as_closure().args),
                     );
                     let func_val = Rc::new(func_const.clone().into());
                     self.bv
diff --git a/checker/src/body_visitor.rs b/checker/src/body_visitor.rs
index 13453ad4..7b7420db 100644
--- a/checker/src/body_visitor.rs
+++ b/checker/src/body_visitor.rs
@@ -17,8 +17,7 @@ use mirai_annotations::*;
 use rustc_errors::DiagnosticBuilder;
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir;
-use rustc_middle::ty::subst::SubstsRef;
-use rustc_middle::ty::{AdtDef, Const, Ty, TyCtxt, TyKind, TypeAndMut, UintTy};
+use rustc_middle::ty::{AdtDef, Const, GenericArgsRef, Ty, TyCtxt, TyKind, TypeAndMut, UintTy};
 
 use crate::abstract_value::{self, AbstractValue, AbstractValueTrait, BOTTOM};
 use crate::block_visitor::BlockVisitor;
@@ -634,7 +633,7 @@ impl<'analysis, 'compilation, 'tcx> BodyVisitor<'analysis, 'compilation, 'tcx> {
             if self.active_calls_map.contains_key(&def_id) {
                 return;
             }
-            let generic_args = self.cv.substs_cache.get(&def_id).cloned();
+            let generic_args = self.cv.generic_args_cache.get(&def_id).cloned();
             let callee_generic_argument_map = if let Some(generic_args) = generic_args {
                 self.type_visitor()
                     .get_generic_arguments_map(def_id, generic_args, &[])
@@ -1723,13 +1722,13 @@ impl<'analysis, 'compilation, 'tcx> BodyVisitor<'analysis, 'compilation, 'tcx> {
                 let union_type = self
                     .type_visitor()
                     .get_path_rustc_type(qualifier, self.current_span);
-                if let TyKind::Adt(def, substs) = union_type.kind() {
-                    let substs = self
+                if let TyKind::Adt(def, args) = union_type.kind() {
+                    let args = self
                         .type_visitor
-                        .specialize_substs(substs, &self.type_visitor().generic_argument_map);
+                        .specialize_generic_args(args, &self.type_visitor().generic_argument_map);
                     for (i, field) in def.all_fields().enumerate() {
                         let target_type = self.type_visitor().specialize_generic_argument_type(
-                            field.ty(self.tcx, substs),
+                            field.ty(self.tcx, args),
                             &self.type_visitor().generic_argument_map,
                         );
                         let target_path = Path::new_union_field(qualifier.clone(), i, *num_cases);
@@ -1794,7 +1793,7 @@ impl<'analysis, 'compilation, 'tcx> BodyVisitor<'analysis, 'compilation, 'tcx> {
         fn add_leaf_fields_for<'a>(
             path: Rc<Path>,
             def: &'a AdtDef,
-            substs: SubstsRef<'a>,
+            args: GenericArgsRef<'a>,
             tcx: TyCtxt<'a>,
             accumulator: &mut Vec<(Rc<Path>, Ty<'a>)>,
         ) {
@@ -1823,9 +1822,9 @@ impl<'analysis, 'compilation, 'tcx> BodyVisitor<'analysis, 'compilation, 'tcx> {
                 let variant = def.variants().iter().next().expect("at least one variant");
                 for (i, field) in variant.fields.iter().enumerate() {
                     let field_path = Path::new_field(path.clone(), i);
-                    let field_ty = field.ty(tcx, substs);
-                    if let TyKind::Adt(def, substs) = field_ty.kind() {
-                        add_leaf_fields_for(field_path, def, substs, tcx, accumulator)
+                    let field_ty = field.ty(tcx, args);
+                    if let TyKind::Adt(def, args) = field_ty.kind() {
+                        add_leaf_fields_for(field_path, def, args, tcx, accumulator)
                     } else {
                         accumulator.push((field_path, field_ty))
                     }
@@ -2674,18 +2673,19 @@ impl<'analysis, 'compilation, 'tcx> BodyVisitor<'analysis, 'compilation, 'tcx> {
                     let union_type = self
                         .type_visitor()
                         .get_path_rustc_type(qualifier, self.current_span);
-                    if let TyKind::Adt(def, substs) = union_type.kind() {
-                        let substs = self
-                            .type_visitor
-                            .specialize_substs(substs, &self.type_visitor().generic_argument_map);
+                    if let TyKind::Adt(def, args) = union_type.kind() {
+                        let generic_args = self.type_visitor.specialize_generic_args(
+                            args,
+                            &self.type_visitor().generic_argument_map,
+                        );
                         let source_field = def.all_fields().nth(*case_index).unwrap();
                         let source_type = self.type_visitor().specialize_generic_argument_type(
-                            source_field.ty(self.tcx, substs),
+                            source_field.ty(self.tcx, generic_args),
                             &self.type_visitor().generic_argument_map,
                         );
                         for (i, field) in def.all_fields().enumerate() {
                             let target_type = self.type_visitor().specialize_generic_argument_type(
-                                field.ty(self.tcx, substs),
+                                field.ty(self.tcx, generic_args),
                                 &self.type_visitor().generic_argument_map,
                             );
                             let target_path =
diff --git a/checker/src/call_visitor.rs b/checker/src/call_visitor.rs
index 2498d8f8..0d500404 100644
--- a/checker/src/call_visitor.rs
+++ b/checker/src/call_visitor.rs
@@ -12,8 +12,7 @@ use log_derive::*;
 use mirai_annotations::*;
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir;
-use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
-use rustc_middle::ty::{Ty, TyKind, UintTy};
+use rustc_middle::ty::{GenericArg, GenericArgKind, GenericArgsRef, Ty, TyKind, UintTy};
 use rustc_target::abi::VariantIdx;
 
 use crate::abstract_value::{AbstractValue, AbstractValueTrait};
@@ -38,7 +37,7 @@ pub struct CallVisitor<'call, 'block, 'analysis, 'compilation, 'tcx> {
     pub callee_def_id: DefId,
     pub callee_func_ref: Option<Rc<FunctionReference>>,
     pub callee_fun_val: Rc<AbstractValue>,
-    pub callee_generic_arguments: Option<SubstsRef<'tcx>>,
+    pub callee_generic_arguments: Option<GenericArgsRef<'tcx>>,
     pub callee_known_name: KnownNames,
     pub callee_generic_argument_map: Option<HashMap<rustc_span::Symbol, GenericArg<'tcx>>>,
     pub unwind: mir::UnwindAction,
@@ -63,7 +62,7 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
     pub(crate) fn new(
         block_visitor: &'call mut BlockVisitor<'block, 'analysis, 'compilation, 'tcx>,
         callee_def_id: DefId,
-        callee_generic_arguments: Option<SubstsRef<'tcx>>,
+        callee_generic_arguments: Option<GenericArgsRef<'tcx>>,
         callee_generic_argument_map: Option<HashMap<rustc_span::Symbol, GenericArg<'tcx>>>,
         environment_before_call: Environment,
         func_const: ConstantDomain,
@@ -244,7 +243,7 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
                 let resolved_ty = tcx.type_of(resolved_def_id).skip_binder();
                 let resolved_map = self.type_visitor().get_generic_arguments_map(
                     resolved_def_id,
-                    instance.substs,
+                    instance.args,
                     &[],
                 );
                 let specialized_resolved_ty = self
@@ -260,7 +259,7 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
                     .visit_function_reference(
                         resolved_def_id,
                         specialized_resolved_ty,
-                        Some(instance.substs),
+                        Some(instance.args),
                     )
                     .clone();
                 self.callee_func_ref = if let ConstantDomain::Function(fr) = &func_const {
@@ -270,10 +269,10 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
                     None
                 };
                 self.callee_fun_val = Rc::new(func_const.into());
-                self.callee_generic_arguments = Some(instance.substs);
+                self.callee_generic_arguments = Some(instance.args);
                 self.callee_generic_argument_map = self.type_visitor().get_generic_arguments_map(
                     resolved_def_id,
-                    instance.substs,
+                    instance.args,
                     &self.actual_argument_types,
                 );
                 if has_mir && specialized_resolved_ty.is_closure() {
@@ -666,7 +665,7 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
     fn handled_clone(&mut self) -> bool {
         precondition!(self.actual_argument_types.len() == 1);
         if let TyKind::Ref(_, t, _) = self.actual_argument_types[0].kind() {
-            if let TyKind::Adt(def, substs) = t.kind() {
+            if let TyKind::Adt(def, args) = t.kind() {
                 if def.variants().is_empty() {
                     return false;
                 }
@@ -707,9 +706,11 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
                             {
                                 // The caller might be able to avoid the diagnostic because it
                                 // knows the actual argument whereas here we only know the type.
-                                let specialized_substs = self
-                                    .type_visitor()
-                                    .specialize_substs(substs, &self.callee_generic_argument_map);
+                                let specialized_substs =
+                                    self.type_visitor().specialize_generic_args(
+                                        args,
+                                        &self.callee_generic_argument_map,
+                                    );
                                 if !utils::are_concrete(specialized_substs) {
                                     // The clone method will not resolve, but we don't want visit_caller
                                     // to issue a diagnostic because is_zero might refine to true
@@ -1266,31 +1267,35 @@ impl<'call, 'block, 'analysis, 'compilation, 'tcx>
 
             // Get the generic argument map for the indirectly called function
             let generic_arguments = match callee_ty.kind() {
-                TyKind::Closure(_, substs) => Some(self.type_visitor().specialize_substs(
-                    substs.as_closure().substs,
+                TyKind::Closure(_, args) => Some(self.type_visitor().specialize_generic_args(
+                    args.as_closure().args,
                     &self.type_visitor().generic_argument_map,
                 )),
-                TyKind::Generator(_, substs, _) => Some(self.type_visitor().specialize_substs(
-                    substs.as_generator().substs,
+                TyKind::Generator(_, args, _) => Some(self.type_visitor().specialize_generic_args(
+                    args.as_generator().args,
                     &self.type_visitor().generic_argument_map,
                 )),
-                TyKind::FnDef(_, substs)
-                | TyKind::Alias(
-                    rustc_middle::ty::Opaque,
-                    rustc_middle::ty::AliasTy { substs, .. },
-                ) => Some(
-                    self.type_visitor()
-                        .specialize_substs(substs, &self.type_visitor().generic_argument_map),
-                ),
-                _ => self.block_visitor.bv.cv.substs_cache.get(&def_id).cloned(),
+                TyKind::FnDef(_, args)
+                | TyKind::Alias(rustc_middle::ty::Opaque, rustc_middle::ty::AliasTy { args, .. }) => {
+                    Some(
+                        self.type_visitor().specialize_generic_args(
+                            args,
+                            &self.type_visitor().generic_argument_map,
+                        ),
+                    )
+                }
+                _ => self
+                    .block_visitor
+                    .bv
+                    .cv
+                    .generic_args_cache
+                    .get(&def_id)
+                    .cloned(),
             };
 
-            let argument_map = if let Some(substs) = generic_arguments {
-                self.type_visitor().get_generic_arguments_map(
-                    def_id,
-                    substs,
-                    &actual_argument_types,
-                )
+            let argument_map = if let Some(args) = generic_arguments {
+                self.type_visitor()
+                    .get_generic_arguments_map(def_id, args, &actual_argument_types)
             } else {
                 None
             };
diff --git a/checker/src/callbacks.rs b/checker/src/callbacks.rs
index 11dab01f..a95654a5 100644
--- a/checker/src/callbacks.rs
+++ b/checker/src/callbacks.rs
@@ -162,7 +162,7 @@ impl MiraiCallbacks {
             known_names_cache: KnownNamesCache::create_cache_from_language_items(),
             options: &std::mem::take(&mut self.options),
             session: compiler.session(),
-            substs_cache: HashMap::new(),
+            generic_args_cache: HashMap::new(),
             summary_cache: PersistentSummaryCache::new(tcx, summary_store_path),
             tcx,
             test_run: self.test_run,
diff --git a/checker/src/constant_domain.rs b/checker/src/constant_domain.rs
index 8d660ad4..ac060491 100644
--- a/checker/src/constant_domain.rs
+++ b/checker/src/constant_domain.rs
@@ -13,8 +13,7 @@ use serde::{Deserialize, Serialize};
 
 use mirai_annotations::*;
 use rustc_hir::def_id::DefId;
-use rustc_middle::ty::subst::SubstsRef;
-use rustc_middle::ty::{Ty, TyCtxt};
+use rustc_middle::ty::{GenericArgsRef, Ty, TyCtxt};
 
 use crate::expression::{Expression, ExpressionType};
 use crate::known_names::{KnownNames, KnownNamesCache};
@@ -114,7 +113,7 @@ impl ConstantDomain {
     pub fn for_function<'a, 'tcx>(
         function_id: usize,
         def_id: DefId,
-        generic_args: Option<SubstsRef<'tcx>>,
+        generic_args: Option<GenericArgsRef<'tcx>>,
         tcx: TyCtxt<'tcx>,
         known_names_cache: &mut KnownNamesCache,
         summary_cache: &mut PersistentSummaryCache<'tcx>,
@@ -1260,7 +1259,7 @@ impl<'tcx> ConstantValueCache<'tcx> {
         &mut self,
         def_id: DefId,
         ty: Ty<'tcx>,
-        generic_args: Option<SubstsRef<'tcx>>,
+        generic_args: Option<GenericArgsRef<'tcx>>,
         tcx: TyCtxt<'tcx>,
         known_names_cache: &mut KnownNamesCache,
         summary_cache: &mut PersistentSummaryCache<'tcx>,
diff --git a/checker/src/crate_visitor.rs b/checker/src/crate_visitor.rs
index 8bd997da..3c383aeb 100644
--- a/checker/src/crate_visitor.rs
+++ b/checker/src/crate_visitor.rs
@@ -22,8 +22,7 @@ use mirai_annotations::*;
 use rustc_errors::{Diagnostic, DiagnosticBuilder};
 use rustc_hir::def_id::{DefId, DefIndex};
 use rustc_middle::mir;
-use rustc_middle::ty::subst::SubstsRef;
-use rustc_middle::ty::{TyCtxt, UnevaluatedConst};
+use rustc_middle::ty::{GenericArgsRef, TyCtxt, UnevaluatedConst};
 use rustc_session::Session;
 
 use crate::body_visitor::BodyVisitor;
@@ -50,10 +49,10 @@ pub struct CrateVisitor<'compilation, 'tcx> {
     pub constant_value_cache: ConstantValueCache<'tcx>,
     pub diagnostics_for: HashMap<DefId, Vec<DiagnosticBuilder<'compilation, ()>>>,
     pub file_name: &'compilation str,
+    pub generic_args_cache: HashMap<DefId, GenericArgsRef<'tcx>>,
     pub known_names_cache: KnownNamesCache,
     pub options: &'compilation Options,
     pub session: &'compilation Session,
-    pub substs_cache: HashMap<DefId, SubstsRef<'tcx>>,
     pub summary_cache: PersistentSummaryCache<'tcx>,
     pub tcx: TyCtxt<'tcx>,
     pub type_cache: Rc<RefCell<TypeCache<'tcx>>>,
diff --git a/checker/src/type_visitor.rs b/checker/src/type_visitor.rs
index ea02d6ff..9e85d011 100644
--- a/checker/src/type_visitor.rs
+++ b/checker/src/type_visitor.rs
@@ -15,10 +15,10 @@ use mirai_annotations::*;
 use rustc_hir::def_id::DefId;
 use rustc_index::Idx;
 use rustc_middle::mir;
-use rustc_middle::ty::subst::{GenericArg, GenericArgKind, InternalSubsts, SubstsRef};
 use rustc_middle::ty::{
     AdtDef, Const, ConstKind, ExistentialPredicate, ExistentialProjection, ExistentialTraitRef,
-    FnSig, ParamTy, Ty, TyCtxt, TyKind, TypeAndMut,
+    FnSig, GenericArg, GenericArgKind, GenericArgs, GenericArgsRef, ParamTy, Ty, TyCtxt, TyKind,
+    TypeAndMut,
 };
 use rustc_target::abi::VariantIdx;
 
@@ -78,7 +78,7 @@ pub struct TypeVisitor<'tcx> {
     pub closures_being_specialized: RefCell<HashSet<DefId>>,
     pub def_id: DefId,
     pub generic_argument_map: Option<HashMap<rustc_span::Symbol, GenericArg<'tcx>>>,
-    pub generic_arguments: Option<SubstsRef<'tcx>>,
+    pub generic_arguments: Option<GenericArgsRef<'tcx>>,
     pub mir: &'tcx mir::Body<'tcx>,
     path_ty_cache: HashMap<Rc<Path>, Ty<'tcx>>,
     pub dummy_untagged_value_type: Ty<'tcx>,
@@ -140,9 +140,9 @@ impl<'tcx> TypeVisitor<'tcx> {
             path_ty = t;
         }
         match path_ty.kind() {
-            TyKind::Closure(_, substs) => {
-                if utils::are_concrete(substs) {
-                    for (i, ty) in substs.as_closure().upvar_tys().enumerate() {
+            TyKind::Closure(_, args) => {
+                if utils::are_concrete(args) {
+                    for (i, ty) in args.as_closure().upvar_tys().enumerate() {
                         let var_type = ExpressionType::from(ty.kind());
                         let mut qualifier = path.clone();
                         if is_ref {
@@ -158,8 +158,8 @@ impl<'tcx> TypeVisitor<'tcx> {
                     }
                 }
             }
-            TyKind::Generator(_, substs, _) => {
-                for (i, ty) in substs.as_generator().prefix_tys().enumerate() {
+            TyKind::Generator(_, args, _) => {
+                for (i, ty) in args.as_generator().prefix_tys().enumerate() {
                     let var_type = ExpressionType::from(ty.kind());
                     let mut qualifier = path.clone();
                     if is_ref {
@@ -176,9 +176,9 @@ impl<'tcx> TypeVisitor<'tcx> {
             }
             TyKind::Alias(
                 rustc_middle::ty::Opaque,
-                rustc_middle::ty::AliasTy { def_id, substs, .. },
+                rustc_middle::ty::AliasTy { def_id, args, .. },
             ) => {
-                let map = self.get_generic_arguments_map(*def_id, substs, &[]);
+                let map = self.get_generic_arguments_map(*def_id, args, &[]);
                 let path_ty = self.specialize_generic_argument_type(
                     self.tcx.type_of(*def_id).skip_binder(),
                     &map,
@@ -454,10 +454,10 @@ impl<'tcx> TypeVisitor<'tcx> {
                     | PathSelector::Field(ordinal) => {
                         if let TyKind::Alias(
                             rustc_middle::ty::Opaque,
-                            rustc_middle::ty::AliasTy { def_id, substs, .. },
+                            rustc_middle::ty::AliasTy { def_id, args, .. },
                         ) = &t.kind()
                         {
-                            let map = self.get_generic_arguments_map(*def_id, substs, &[]);
+                            let map = self.get_generic_arguments_map(*def_id, args, &[]);
                             t = self.specialize_generic_argument_type(
                                 self.tcx.type_of(*def_id).skip_binder(),
                                 &map,
@@ -466,8 +466,8 @@ impl<'tcx> TypeVisitor<'tcx> {
                             trace!("opaque type_of {:?}", t);
                         }
                         match t.kind() {
-                            TyKind::Adt(def, substs) => {
-                                return self.get_field_type(def, substs, *ordinal);
+                            TyKind::Adt(def, args) => {
+                                return self.get_field_type(def, args, *ordinal);
                             }
                             TyKind::Array(elem_ty, ..) | TyKind::Slice(elem_ty) => {
                                 match *ordinal {
@@ -487,8 +487,8 @@ impl<'tcx> TypeVisitor<'tcx> {
                                     _ => {}
                                 }
                             }
-                            TyKind::Closure(def_id, substs) => {
-                                let closure_substs = substs.as_closure();
+                            TyKind::Closure(def_id, args) => {
+                                let closure_substs = args.as_closure();
                                 if closure_substs.is_valid() {
                                     return closure_substs
                                         .upvar_tys()
@@ -502,9 +502,9 @@ impl<'tcx> TypeVisitor<'tcx> {
                                         });
                                 }
                             }
-                            TyKind::Generator(def_id, substs, _) => {
+                            TyKind::Generator(def_id, args, _) => {
                                 let mut tuple_types =
-                                    substs.as_generator().state_tys(*def_id, self.tcx);
+                                    args.as_generator().state_tys(*def_id, self.tcx);
                                 if let Some(field_tys) = tuple_types.nth(*ordinal) {
                                     return Ty::new_tup_from_iter(self.tcx, field_tys);
                                 }
@@ -516,9 +516,9 @@ impl<'tcx> TypeVisitor<'tcx> {
                                 // why would getting a field from a closure not need a deref
                                 // before the field access? I.e. is a reference to a closure
                                 // a sort of fat pointer?
-                                if let TyKind::Closure(def_id, substs) = t.kind() {
-                                    if utils::are_concrete(substs) {
-                                        return substs
+                                if let TyKind::Closure(def_id, args) = t.kind() {
+                                    if utils::are_concrete(args) {
+                                        return args
                                             .as_closure()
                                             .upvar_tys()
                                             .nth(*ordinal)
@@ -614,18 +614,18 @@ impl<'tcx> TypeVisitor<'tcx> {
                         while type_visitor::is_transparent_wrapper(t)
                             || matches!(t.kind(), TyKind::Adt(..))
                         {
-                            if let TyKind::Adt(def, substs) = t.kind() {
-                                let substs =
-                                    self.specialize_substs(substs, &self.generic_argument_map);
+                            if let TyKind::Adt(def, args) = t.kind() {
+                                let args =
+                                    self.specialize_generic_args(args, &self.generic_argument_map);
                                 if !def.is_enum() {
                                     // Could be a *&S vs *&S.Field_0 confusion
-                                    t = self.get_field_type(def, substs, 0);
+                                    t = self.get_field_type(def, args, 0);
                                     continue;
                                 }
                                 if *ordinal < def.variants().len() {
                                     let variant = &def.variants()[VariantIdx::new(*ordinal)];
                                     let field_tys =
-                                        variant.fields.iter().map(|fd| fd.ty(self.tcx, substs));
+                                        variant.fields.iter().map(|fd| fd.ty(self.tcx, args));
                                     return Ty::new_tup_from_iter(self.tcx, field_tys);
                                 }
                                 if !type_visitor::is_transparent_wrapper(t) {
@@ -719,13 +719,13 @@ impl<'tcx> TypeVisitor<'tcx> {
     pub fn get_field_type(
         &self,
         def: &'tcx AdtDef,
-        substs: SubstsRef<'tcx>,
+        args: GenericArgsRef<'tcx>,
         ordinal: usize,
     ) -> Ty<'tcx> {
         for variant in def.variants().iter() {
             if ordinal < variant.fields.len() {
                 let field = &variant.fields[ordinal.into()];
-                let ft = field.ty(self.tcx, substs);
+                let ft = field.ty(self.tcx, args);
                 trace!("field {:?} type is {:?}", ordinal, ft);
                 return ft;
             }
@@ -784,7 +784,7 @@ impl<'tcx> TypeVisitor<'tcx> {
     pub fn get_generic_arguments_map(
         &self,
         def_id: DefId,
-        generic_args: SubstsRef<'tcx>,
+        generic_args: GenericArgsRef<'tcx>,
         actual_argument_types: &[Ty<'tcx>],
     ) -> Option<HashMap<rustc_span::Symbol, GenericArg<'tcx>>> {
         let mut substitution_map = self.generic_argument_map.clone();
@@ -795,7 +795,7 @@ impl<'tcx> TypeVisitor<'tcx> {
         // as well. This applies recursively. Note that a child cannot mask the
         // generic parameters of its parent with one of its own, so each parameter
         // definition in this iteration will have a unique name.
-        InternalSubsts::for_item(self.tcx, def_id, |param_def, _| {
+        GenericArgs::for_item(self.tcx, def_id, |param_def, _| {
             if let Some(gen_arg) = generic_args.get(param_def.index as usize) {
                 let specialized_gen_arg =
                     self.specialize_generic_argument(*gen_arg, &substitution_map);
@@ -942,7 +942,7 @@ impl<'tcx> TypeVisitor<'tcx> {
                 }
                 mir::ProjectionElem::OpaqueCast(ty) => *ty,
                 mir::ProjectionElem::Downcast(_, ordinal) => {
-                    if let TyKind::Adt(def, substs) = base_ty.kind() {
+                    if let TyKind::Adt(def, args) = base_ty.kind() {
                         if ordinal.index() >= def.variants().len() {
                             debug!(
                                 "illegally down casting to index {} of {:?} at {:?}",
@@ -951,14 +951,14 @@ impl<'tcx> TypeVisitor<'tcx> {
                                 current_span
                             );
                             let variant = &def.variants().iter().last().unwrap();
-                            let field_tys = variant.fields.iter().map(|fd| fd.ty(self.tcx, substs));
+                            let field_tys = variant.fields.iter().map(|fd| fd.ty(self.tcx, args));
                             return Ty::new_tup_from_iter(self.tcx, field_tys);
                         }
                         let variant = &def.variants()[*ordinal];
-                        let field_tys = variant.fields.iter().map(|fd| fd.ty(self.tcx, substs));
+                        let field_tys = variant.fields.iter().map(|fd| fd.ty(self.tcx, args));
                         return Ty::new_tup_from_iter(self.tcx, field_tys);
-                    } else if let TyKind::Generator(def_id, substs, ..) = base_ty.kind() {
-                        let mut tuple_types = substs.as_generator().state_tys(*def_id, self.tcx);
+                    } else if let TyKind::Generator(def_id, args, ..) = base_ty.kind() {
+                        let mut tuple_types = args.as_generator().state_tys(*def_id, self.tcx);
                         if let Some(field_tys) = tuple_types.nth(ordinal.index()) {
                             return Ty::new_tup_from_iter(self.tcx, field_tys);
                         }
@@ -1017,7 +1017,7 @@ impl<'tcx> TypeVisitor<'tcx> {
     }
 
     pub fn remove_transparent_wrapper(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        if let TyKind::Adt(def, substs) = ty.kind() {
+        if let TyKind::Adt(def, args) = ty.kind() {
             if def.repr().transparent() {
                 let variant_0 = VariantIdx::from_u32(0);
                 let v = &def.variants()[variant_0];
@@ -1029,7 +1029,7 @@ impl<'tcx> TypeVisitor<'tcx> {
                     !is_zst
                 });
                 if let Some(f) = non_zst_field {
-                    return f.ty(self.tcx, substs);
+                    return f.ty(self.tcx, args);
                 }
             }
         }
@@ -1072,7 +1072,7 @@ impl<'tcx> TypeVisitor<'tcx> {
         // The projection of an associated type. For example,
         // `<T as Trait<..>>::N`.
         if let TyKind::Alias(rustc_middle::ty::Projection, projection) = gen_arg_type.kind() {
-            let specialized_substs = self.specialize_substs(projection.substs, map);
+            let specialized_substs = self.specialize_generic_args(projection.args, map);
             let item_def_id = projection.def_id;
             return if utils::are_concrete(specialized_substs) {
                 let param_env = self
@@ -1090,7 +1090,7 @@ impl<'tcx> TypeVisitor<'tcx> {
                     }
                     let item_type = self.tcx.type_of(instance_item_def_id).skip_binder();
                     let map =
-                        self.get_generic_arguments_map(instance_item_def_id, instance.substs, &[]);
+                        self.get_generic_arguments_map(instance_item_def_id, instance.args, &[]);
                     if item_type == gen_arg_type && map.is_none() {
                         // Can happen if the projection just adds a life time
                         item_type
@@ -1121,8 +1121,8 @@ impl<'tcx> TypeVisitor<'tcx> {
             return gen_arg_type;
         }
         match gen_arg_type.kind() {
-            TyKind::Adt(def, substs) => {
-                Ty::new_adt(self.tcx, *def, self.specialize_substs(substs, map))
+            TyKind::Adt(def, args) => {
+                Ty::new_adt(self.tcx, *def, self.specialize_generic_args(args, map))
             }
             TyKind::Array(elem_ty, len) => {
                 let specialized_elem_ty = self.specialize_generic_argument_type(*elem_ty, map);
@@ -1155,8 +1155,8 @@ impl<'tcx> TypeVisitor<'tcx> {
                     },
                 )
             }
-            TyKind::FnDef(def_id, substs) => {
-                Ty::new_fn_def(self.tcx, *def_id, self.specialize_substs(substs, map))
+            TyKind::FnDef(def_id, args) => {
+                Ty::new_fn_def(self.tcx, *def_id, self.specialize_generic_args(args, map))
             }
             TyKind::FnPtr(fn_sig) => {
                 let map_fn_sig = |fn_sig: FnSig<'tcx>| {
@@ -1180,27 +1180,27 @@ impl<'tcx> TypeVisitor<'tcx> {
                 let specialized_predicates = predicates.iter().map(
                     |bound_pred: rustc_middle::ty::Binder<'_, ExistentialPredicate<'tcx>>| {
                         bound_pred.map_bound(|pred| match pred {
-                            ExistentialPredicate::Trait(ExistentialTraitRef { def_id, substs }) => {
+                            ExistentialPredicate::Trait(ExistentialTraitRef { def_id, args }) => {
                                 ExistentialPredicate::Trait(ExistentialTraitRef {
                                     def_id,
-                                    substs: self.specialize_substs(substs, map),
+                                    args: self.specialize_generic_args(args, map),
                                 })
                             }
                             ExistentialPredicate::Projection(ExistentialProjection {
                                 def_id,
-                                substs,
+                                args,
                                 term,
                             }) => {
                                 if let Some(ty) = term.ty() {
                                     ExistentialPredicate::Projection(ExistentialProjection {
                                         def_id,
-                                        substs: self.specialize_substs(substs, map),
+                                        args: self.specialize_generic_args(args, map),
                                         term: self.specialize_generic_argument_type(ty, map).into(),
                                     })
                                 } else {
                                     ExistentialPredicate::Projection(ExistentialProjection {
                                         def_id,
-                                        substs: self.specialize_substs(substs, map),
+                                        args: self.specialize_generic_args(args, map),
                                         term,
                                     })
                                 }
@@ -1217,7 +1217,7 @@ impl<'tcx> TypeVisitor<'tcx> {
                     *kind,
                 )
             }
-            TyKind::Closure(def_id, substs) => {
+            TyKind::Closure(def_id, args) => {
                 // Closure types can be part of their own type parameters...
                 // so need to guard against endless recursion
                 {
@@ -1230,17 +1230,17 @@ impl<'tcx> TypeVisitor<'tcx> {
                     }
                 }
                 let specialized_closure =
-                    Ty::new_closure(self.tcx, *def_id, self.specialize_substs(substs, map));
+                    Ty::new_closure(self.tcx, *def_id, self.specialize_generic_args(args, map));
                 let mut borrowed_closures_being_specialized =
                     self.closures_being_specialized.borrow_mut();
                 let closures_being_specialized = borrowed_closures_being_specialized.deref_mut();
                 closures_being_specialized.remove(def_id);
                 specialized_closure
             }
-            TyKind::Generator(def_id, substs, movability) => Ty::new_generator(
+            TyKind::Generator(def_id, args, movability) => Ty::new_generator(
                 self.tcx,
                 *def_id,
-                self.specialize_substs(substs, map),
+                self.specialize_generic_args(args, map),
                 *movability,
             ),
             TyKind::GeneratorWitness(bound_types) => {
@@ -1262,8 +1262,8 @@ impl<'tcx> TypeVisitor<'tcx> {
             ),
             TyKind::Alias(
                 rustc_middle::ty::Opaque,
-                rustc_middle::ty::AliasTy { def_id, substs, .. },
-            ) => Ty::new_opaque(self.tcx, *def_id, self.specialize_substs(substs, map)),
+                rustc_middle::ty::AliasTy { def_id, args, .. },
+            ) => Ty::new_opaque(self.tcx, *def_id, self.specialize_generic_args(args, map)),
             TyKind::Param(ParamTy { name, .. }) => {
                 if let Some(map) = map {
                     if let Some(gen_arg) = map.get(name) {
@@ -1277,16 +1277,16 @@ impl<'tcx> TypeVisitor<'tcx> {
     }
 
     #[logfn_inputs(TRACE)]
-    pub fn specialize_substs(
+    pub fn specialize_generic_args(
         &self,
-        substs: SubstsRef<'tcx>,
+        args: GenericArgsRef<'tcx>,
         map: &Option<HashMap<rustc_span::Symbol, GenericArg<'tcx>>>,
-    ) -> SubstsRef<'tcx> {
-        let specialized_generic_args: Vec<GenericArg<'_>> = substs
+    ) -> GenericArgsRef<'tcx> {
+        let specialized_generic_args: Vec<GenericArg<'_>> = args
             .iter()
             .map(|gen_arg| self.specialize_generic_argument(gen_arg, map))
             .collect();
-        self.tcx.mk_substs(&specialized_generic_args)
+        self.tcx.mk_args(&specialized_generic_args)
     }
 }
 
diff --git a/checker/src/utils.rs b/checker/src/utils.rs
index e13ff209..40abc3a2 100644
--- a/checker/src/utils.rs
+++ b/checker/src/utils.rs
@@ -16,8 +16,9 @@ use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
 use rustc_hir::Node;
 use rustc_middle::ty;
 use rustc_middle::ty::print::{FmtPrinter, Printer};
-use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
-use rustc_middle::ty::{FloatTy, IntTy, Ty, TyCtxt, TyKind, UintTy};
+use rustc_middle::ty::{
+    FloatTy, GenericArgKind, GenericArgsRef, IntTy, Ty, TyCtxt, TyKind, UintTy,
+};
 
 /// Returns the location of the rust system binaries that are associated with this build of Mirai.
 /// The location is obtained by looking at the contents of the environmental variables that were
@@ -70,10 +71,10 @@ pub fn contains_function<'tcx>(ty: Ty<'tcx>, tcx: TyCtxt<'tcx>) -> bool {
     if ty.is_fn() || ty.is_closure() || ty.is_generator() {
         return true;
     }
-    if let TyKind::Adt(def, substs) = ty.kind() {
+    if let TyKind::Adt(def, args) = ty.kind() {
         for variant in def.variants().iter() {
             for (_, field) in variant.fields.iter().enumerate() {
-                let field_ty = field.ty(tcx, substs);
+                let field_ty = field.ty(tcx, args);
                 if contains_function(field_ty, tcx) {
                     return true;
                 }
@@ -152,7 +153,7 @@ pub fn is_trait_method(def_id: DefId, tcx: TyCtxt<'_>) -> bool {
 #[logfn(TRACE)]
 pub fn argument_types_key_str<'tcx>(
     tcx: TyCtxt<'tcx>,
-    generic_args: Option<SubstsRef<'tcx>>,
+    generic_args: Option<GenericArgsRef<'tcx>>,
 ) -> Rc<str> {
     let mut result = "_".to_string();
     if let Some(generic_args) = generic_args {
@@ -211,7 +212,7 @@ fn append_mangled_type<'tcx>(str: &mut String, ty: Ty<'tcx>, tcx: TyCtxt<'tcx>)
         TyKind::Closure(def_id, subs) => {
             str.push_str("closure_");
             str.push_str(qualified_type_name(tcx, *def_id).as_str());
-            for sub in subs.as_closure().substs {
+            for sub in subs.as_closure().args {
                 if let GenericArgKind::Type(ty) = sub.unpack() {
                     str.push('_');
                     append_mangled_type(str, ty, tcx);
@@ -224,7 +225,7 @@ fn append_mangled_type<'tcx>(str: &mut String, ty: Ty<'tcx>, tcx: TyCtxt<'tcx>)
                 let principal =
                     tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), principal);
                 str.push_str(qualified_type_name(tcx, principal.def_id).as_str());
-                for sub in principal.substs {
+                for sub in principal.args {
                     if let GenericArgKind::Type(ty) = sub.unpack() {
                         str.push('_');
                         append_mangled_type(str, ty, tcx);
@@ -249,7 +250,7 @@ fn append_mangled_type<'tcx>(str: &mut String, ty: Ty<'tcx>, tcx: TyCtxt<'tcx>)
         TyKind::Generator(def_id, subs, ..) => {
             str.push_str("generator_");
             str.push_str(qualified_type_name(tcx, *def_id).as_str());
-            for sub in subs.as_generator().substs {
+            for sub in subs.as_generator().args {
                 if let GenericArgKind::Type(ty) = sub.unpack() {
                     str.push('_');
                     append_mangled_type(str, ty, tcx);
@@ -262,13 +263,10 @@ fn append_mangled_type<'tcx>(str: &mut String, ty: Ty<'tcx>, tcx: TyCtxt<'tcx>)
                 append_mangled_type(str, ty, tcx)
             }
         }
-        TyKind::Alias(
-            rustc_middle::ty::Opaque,
-            rustc_middle::ty::AliasTy { def_id, substs, .. },
-        ) => {
+        TyKind::Alias(rustc_middle::ty::Opaque, rustc_middle::ty::AliasTy { def_id, args, .. }) => {
             str.push_str("impl_");
             str.push_str(qualified_type_name(tcx, *def_id).as_str());
-            for sub in *substs {
+            for sub in *args {
                 if let GenericArgKind::Type(ty) = sub.unpack() {
                     str.push('_');
                     append_mangled_type(str, ty, tcx);
@@ -446,8 +444,8 @@ pub fn def_id_as_qualified_name_str(tcx: TyCtxt<'_>, def_id: DefId) -> Rc<str> {
         name.push('(');
         let fn_sig = if fn_ty.is_fn() {
             fn_ty.fn_sig(tcx).skip_binder()
-        } else if let ty::Closure(_, substs) = fn_ty.kind() {
-            substs.as_closure().sig().skip_binder()
+        } else if let ty::Closure(_, args) = fn_ty.kind() {
+            args.as_closure().sig().skip_binder()
         } else {
             unreachable!()
         };
@@ -480,7 +478,7 @@ pub fn def_id_display_name(tcx: TyCtxt<'_>, def_id: DefId) -> String {
 }
 
 /// Returns false if any of the generic arguments are themselves generic
-pub fn are_concrete(gen_args: SubstsRef<'_>) -> bool {
+pub fn are_concrete(gen_args: GenericArgsRef<'_>) -> bool {
     for gen_arg in gen_args.iter() {
         if let GenericArgKind::Type(ty) = gen_arg.unpack() {
             if !is_concrete(ty.kind()) {
@@ -498,12 +496,9 @@ pub fn is_concrete(ty: &TyKind<'_>) -> bool {
         | TyKind::Closure(_, gen_args)
         | TyKind::FnDef(_, gen_args)
         | TyKind::Generator(_, gen_args, _)
-        | TyKind::Alias(
-            _,
-            rustc_middle::ty::AliasTy {
-                substs: gen_args, ..
-            },
-        ) => are_concrete(gen_args),
+        | TyKind::Alias(_, rustc_middle::ty::AliasTy { args: gen_args, .. }) => {
+            are_concrete(gen_args)
+        }
         TyKind::Tuple(types) => types.iter().all(|t| is_concrete(t.kind())),
         TyKind::Bound(..)
         | TyKind::Dynamic(..)
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 1f9dcbf5..2fc522bb 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2023-07-11"
+channel = "nightly-2023-07-18"
 components = [ "clippy", "rustfmt", "rustc-dev", "rust-src", "rust-std", "llvm-tools-preview" ]