diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs index 14442806fc0b7..c4c1ec8ce4e0a 100644 --- a/compiler/rustc_symbol_mangling/src/v0.rs +++ b/compiler/rustc_symbol_mangling/src/v0.rs @@ -23,15 +23,12 @@ pub(super) fn mangle( let substs = tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), instance.substs); let prefix = "_R"; - let mut cx = SymbolMangler { + let mut cx = &mut SymbolMangler { tcx, - compress: Some(Box::new(CompressionCaches { - start_offset: prefix.len(), - - paths: FxHashMap::default(), - types: FxHashMap::default(), - consts: FxHashMap::default(), - })), + start_offset: prefix.len(), + paths: FxHashMap::default(), + types: FxHashMap::default(), + consts: FxHashMap::default(), binders: vec![], out: String::from(prefix), }; @@ -52,17 +49,7 @@ pub(super) fn mangle( if let Some(instantiating_crate) = instantiating_crate { cx = cx.print_def_path(instantiating_crate.as_def_id(), &[]).unwrap(); } - cx.out -} - -struct CompressionCaches<'tcx> { - // The length of the prefix in `out` (e.g. 2 for `_R`). - start_offset: usize, - - // The values are start positions in `out`, in bytes. - paths: FxHashMap<(DefId, &'tcx [GenericArg<'tcx>]), usize>, - types: FxHashMap, usize>, - consts: FxHashMap<&'tcx ty::Const<'tcx>, usize>, + std::mem::take(&mut cx.out) } struct BinderLevel { @@ -81,9 +68,15 @@ struct BinderLevel { struct SymbolMangler<'tcx> { tcx: TyCtxt<'tcx>, - compress: Option>>, binders: Vec, out: String, + + /// The length of the prefix in `out` (e.g. 2 for `_R`). + start_offset: usize, + /// The values are start positions in `out`, in bytes. + paths: FxHashMap<(DefId, &'tcx [GenericArg<'tcx>]), usize>, + types: FxHashMap, usize>, + consts: FxHashMap<&'tcx ty::Const<'tcx>, usize>, } impl SymbolMangler<'tcx> { @@ -160,13 +153,13 @@ impl SymbolMangler<'tcx> { self.push(ident); } - fn path_append_ns( - mut self, - print_prefix: impl FnOnce(Self) -> Result, + fn path_append_ns<'a>( + mut self: &'a mut Self, + print_prefix: impl FnOnce(&'a mut Self) -> Result<&'a mut Self, !>, ns: char, disambiguator: u64, name: &str, - ) -> Result { + ) -> Result<&'a mut Self, !> { self.push("N"); self.out.push(ns); self = print_prefix(self)?; @@ -175,17 +168,17 @@ impl SymbolMangler<'tcx> { Ok(self) } - fn print_backref(mut self, i: usize) -> Result { + fn print_backref(&mut self, i: usize) -> Result<&mut Self, !> { self.push("B"); - self.push_integer_62((i - self.compress.as_ref().unwrap().start_offset) as u64); + self.push_integer_62((i - self.start_offset) as u64); Ok(self) } - fn in_binder( - mut self, + fn in_binder<'a, T>( + mut self: &'a mut Self, value: &ty::Binder<'tcx, T>, - print_value: impl FnOnce(Self, &T) -> Result, - ) -> Result + print_value: impl FnOnce(&'a mut Self, &T) -> Result<&'a mut Self, !>, + ) -> Result<&'a mut Self, !> where T: TypeFoldable<'tcx>, { @@ -218,7 +211,7 @@ impl SymbolMangler<'tcx> { } } -impl Printer<'tcx> for SymbolMangler<'tcx> { +impl Printer<'tcx> for &mut SymbolMangler<'tcx> { type Error = !; type Path = Self; @@ -236,7 +229,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { def_id: DefId, substs: &'tcx [GenericArg<'tcx>], ) -> Result { - if let Some(&i) = self.compress.as_ref().and_then(|c| c.paths.get(&(def_id, substs))) { + if let Some(&i) = self.paths.get(&(def_id, substs)) { return self.print_backref(i); } let start = self.out.len(); @@ -246,9 +239,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { // Only cache paths that do not refer to an enclosing // binder (which would change depending on context). if !substs.iter().any(|k| k.has_escaping_bound_vars()) { - if let Some(c) = &mut self.compress { - c.paths.insert((def_id, substs), start); - } + self.paths.insert((def_id, substs), start); } Ok(self) } @@ -312,7 +303,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { Ok(self) } - fn print_region(mut self, region: ty::Region<'_>) -> Result { + fn print_region(self, region: ty::Region<'_>) -> Result { let i = match *region { // Erased lifetimes use the index 0, for a // shorter mangling of `L_`. @@ -367,7 +358,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { return Ok(self); } - if let Some(&i) = self.compress.as_ref().and_then(|c| c.types.get(&ty)) { + if let Some(&i) = self.types.get(&ty) { return self.print_backref(i); } let start = self.out.len(); @@ -476,9 +467,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { // Only cache types that do not refer to an enclosing // binder (which would change depending on context). if !ty.has_escaping_bound_vars() { - if let Some(c) = &mut self.compress { - c.types.insert(ty, start); - } + self.types.insert(ty, start); } Ok(self) } @@ -545,7 +534,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { } fn print_const(mut self, ct: &'tcx ty::Const<'tcx>) -> Result { - if let Some(&i) = self.compress.as_ref().and_then(|c| c.consts.get(&ct)) { + if let Some(&i) = self.consts.get(&ct) { return self.print_backref(i); } let start = self.out.len(); @@ -583,14 +572,12 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { // Only cache consts that do not refer to an enclosing // binder (which would change depending on context). if !ct.has_escaping_bound_vars() { - if let Some(c) = &mut self.compress { - c.consts.insert(ct, start); - } + self.consts.insert(ct, start); } Ok(self) } - fn path_crate(mut self, cnum: CrateNum) -> Result { + fn path_crate(self, cnum: CrateNum) -> Result { self.push("C"); let stable_crate_id = self.tcx.def_path_hash(cnum.as_def_id()).stable_crate_id(); self.push_disambiguator(stable_crate_id.to_u64());