Remove ParamTypeMapper and stop relaying TypeBuilder

Author: coord-e

src/analyze.rs

@@ -243,10 +243,10 @@ impl<'tcx> Analyzer<'tcx> {
         def_id: DefId,
         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 type_builder = TypeBuilder::new(self.tcx, def_id);
+
                 let mut def_ty = rty.clone();
                 def_ty.instantiate_ty_params(
                     generic_args
@@ -266,9 +266,7 @@ impl<'tcx> Analyzer<'tcx> {
         }
 
         let mut analyzer = self.local_def_analyzer(def_id.as_local()?);
-        analyzer
-            .type_builder(type_builder)
-            .generic_args(generic_args);
+        analyzer.generic_args(generic_args);
 
         let expected = analyzer.expected_ty();
         deferred_ty_cache

src/analyze/basic_block.rs

@@ -983,11 +983,6 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
         self
     }
 
-    pub fn type_builder(&mut self, type_builder: TypeBuilder<'tcx>) -> &mut Self {
-        self.type_builder = type_builder;
-        self
-    }
-
     pub fn run(&mut self, expected: &BasicBlockType) {
         let span = tracing::info_span!("bb", bb = ?self.basic_block);
         let _guard = span.enter();

src/analyze/crate_.rs

@@ -76,7 +76,6 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
 
             // check polymorphic function def by replacing type params with some opaque type
             // (and this is no-op if the function is mono)
-            let type_builder = TypeBuilder::new(self.tcx, local_def_id.to_def_id());
             let mut expected = expected.clone();
             let subst = rty::TypeParamSubst::new(
                 expected
@@ -89,7 +88,6 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
             let generic_args = self.placeholder_generic_args(*local_def_id);
             self.ctx
                 .local_def_analyzer(*local_def_id)
-                .type_builder(type_builder)
                 .generic_args(generic_args)
                 .run(&expected);
         }

src/analyze/local_def.rs

@@ -533,7 +533,6 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
                 .basic_block_analyzer(self.local_def_id, bb)
                 .body(self.body.clone())
                 .drop_points(drop_points)
-                .type_builder(self.type_builder.clone())
                 .run(&rty);
         }
     }
@@ -650,11 +649,6 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
         }
     }
 
-    pub fn type_builder(&mut self, type_builder: TypeBuilder<'tcx>) -> &mut Self {
-        self.type_builder = type_builder;
-        self
-    }
-
     pub fn generic_args(&mut self, generic_args: mir_ty::GenericArgsRef<'tcx>) -> &mut Self {
         self.body =
             mir_ty::EarlyBinder::bind(self.body.clone()).instantiate(self.tcx, generic_args);

src/refine/template.rs

@@ -59,19 +59,6 @@ where
     }
 }
 
-trait ParamTypeMapper {
-    fn map_param_ty(&self, ty: rty::ParamType) -> rty::Type<rty::Closed>;
-}
-
-impl<F> ParamTypeMapper for F
-where
-    F: Fn(rty::ParamType) -> rty::Type<rty::Closed>,
-{
-    fn map_param_ty(&self, ty: rty::ParamType) -> rty::Type<rty::Closed> {
-        self(ty)
-    }
-}
-
 /// Translates [`mir_ty::Ty`] to [`rty::Type`].
 ///
 /// This struct implements a translation from Rust MIR types to Thrust types.
@@ -87,9 +74,6 @@ pub struct TypeBuilder<'tcx> {
     /// mapped when we translate a [`mir_ty::ParamTy`] to [`rty::ParamType`].
     /// See [`rty::TypeParamIdx`] for more details.
     param_idx_mapping: HashMap<u32, rty::TypeParamIdx>,
-    /// Optionally also want to further map rty::ParamType to other rty::Type before generating
-    /// templates. This is no-op by default.
-    param_type_mapper: std::rc::Rc<dyn ParamTypeMapper>,
 }
 
 impl<'tcx> TypeBuilder<'tcx> {
@@ -109,25 +93,15 @@ impl<'tcx> TypeBuilder<'tcx> {
         Self {
             tcx,
             param_idx_mapping,
-            param_type_mapper: std::rc::Rc::new(|ty: rty::ParamType| ty.into()),
         }
     }
 
-    pub fn with_param_mapper<F>(mut self, mapper: F) -> Self
-    where
-        F: Fn(rty::ParamType) -> rty::Type<rty::Closed> + 'static,
-    {
-        self.param_type_mapper = std::rc::Rc::new(mapper);
-        self
-    }
-
     fn translate_param_type(&self, ty: &mir_ty::ParamTy) -> rty::Type<rty::Closed> {
         let index = *self
             .param_idx_mapping
             .get(&ty.index)
             .expect("unknown type param idx");
-        let param_ty = rty::ParamType::new(index);
-        self.param_type_mapper.map_param_ty(param_ty)
+        rty::ParamType::new(index).into()
     }
 
     // TODO: consolidate two impls
@@ -400,17 +374,6 @@ impl<'tcx, 'a, R> FunctionTemplateTypeBuilder<'tcx, 'a, R> {
         self.ret_rty = Some(rty);
         self
     }
-
-    pub fn would_contain_template(&self) -> bool {
-        if self.param_tys.is_empty() {
-            return self.ret_rty.is_none();
-        }
-
-        let last_param_idx = rty::FunctionParamIdx::from(self.param_tys.len() - 1);
-        let param_annotated =
-            self.param_refinement.is_some() || self.param_rtys.contains_key(&last_param_idx);
-        self.ret_rty.is_none() || !param_annotated
-    }
 }
 
 impl<'tcx, 'a, R> FunctionTemplateTypeBuilder<'tcx, 'a, R>