From a621ec35aef00181be89c65a36bc44d061b99206 Mon Sep 17 00:00:00 2001 From: klensy Date: Mon, 24 Apr 2023 13:25:23 +0300 Subject: [PATCH 1/3] RegionInferenceContext: remove Rc from rev_scc_graph field --- compiler/rustc_borrowck/src/region_infer/mod.rs | 6 +++--- .../rustc_borrowck/src/region_infer/reverse_sccs.rs | 13 +++++-------- 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs index 65573c71f14..8fbe814c856 100644 --- a/compiler/rustc_borrowck/src/region_infer/mod.rs +++ b/compiler/rustc_borrowck/src/region_infer/mod.rs @@ -76,7 +76,7 @@ pub struct RegionInferenceContext<'tcx> { /// Reverse of the SCC constraint graph -- i.e., an edge `A -> B` exists if /// `B: A`. This is used to compute the universal regions that are required /// to outlive a given SCC. Computed lazily. - rev_scc_graph: Option>, + rev_scc_graph: Option, /// The "R0 member of [R1..Rn]" constraints, indexed by SCC. member_constraints: Rc>, @@ -813,9 +813,9 @@ fn apply_member_constraint( // free region that must outlive the member region `R0` (`UB: // R0`). Therefore, we need only keep an option `O` if `UB: O` // for all UB. - let rev_scc_graph = self.reverse_scc_graph(); + self.compute_reverse_scc_graph(); let universal_region_relations = &self.universal_region_relations; - for ub in rev_scc_graph.upper_bounds(scc) { + for ub in self.rev_scc_graph.as_ref().unwrap().upper_bounds(scc) { debug!(?ub); choice_regions.retain(|&o_r| universal_region_relations.outlives(ub, o_r)); } diff --git a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs index 23a59c12865..e5c6c4d8540 100644 --- a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs +++ b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs @@ -8,7 +8,6 @@ use rustc_data_structures::graph::WithSuccessors; use rustc_middle::ty::RegionVid; use std::ops::Range; -use std::rc::Rc; pub(crate) struct ReverseSccGraph { graph: VecGraph, @@ -40,10 +39,10 @@ pub(super) fn upper_bounds<'a>( } impl RegionInferenceContext<'_> { - /// Compute and return the reverse SCC-based constraint graph (lazily). - pub(super) fn reverse_scc_graph(&mut self) -> Rc { - if let Some(g) = &self.rev_scc_graph { - return g.clone(); + /// Compute the reverse SCC-based constraint graph (lazily). + pub(super) fn compute_reverse_scc_graph(&mut self) { + if matches!(self.rev_scc_graph, Some(_)) { + return; } let graph = self.constraint_sccs.reverse(); @@ -63,8 +62,6 @@ pub(super) fn reverse_scc_graph(&mut self) -> Rc { start += group_size; } - let rev_graph = Rc::new(ReverseSccGraph { graph, scc_regions, universal_regions }); - self.rev_scc_graph = Some(rev_graph.clone()); - rev_graph + self.rev_scc_graph = Some(ReverseSccGraph { graph, scc_regions, universal_regions }); } } From 597c6514d142886f807cfcfd04291b464bb43787 Mon Sep 17 00:00:00 2001 From: klensy Date: Fri, 28 Apr 2023 13:41:48 +0300 Subject: [PATCH 2/3] Arc -> Lrc --- compiler/rustc_passes/src/debugger_visualizer.rs | 5 ++--- compiler/rustc_span/src/lib.rs | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_passes/src/debugger_visualizer.rs b/compiler/rustc_passes/src/debugger_visualizer.rs index 9dd39a5c9fe..72371b9950b 100644 --- a/compiler/rustc_passes/src/debugger_visualizer.rs +++ b/compiler/rustc_passes/src/debugger_visualizer.rs @@ -2,6 +2,7 @@ use hir::CRATE_HIR_ID; use rustc_data_structures::fx::FxHashSet; +use rustc_data_structures::sync::Lrc; use rustc_expand::base::resolve_path; use rustc_hir as hir; use rustc_hir::HirId; @@ -9,8 +10,6 @@ use rustc_middle::{query::LocalCrate, ty::query::Providers}; use rustc_span::{sym, DebuggerVisualizerFile, DebuggerVisualizerType}; -use std::sync::Arc; - use crate::errors::DebugVisualizerUnreadable; fn check_for_debugger_visualizer( @@ -52,7 +51,7 @@ fn check_for_debugger_visualizer( match std::fs::read(&file) { Ok(contents) => { debugger_visualizers - .insert(DebuggerVisualizerFile::new(Arc::from(contents), visualizer_type)); + .insert(DebuggerVisualizerFile::new(Lrc::from(contents), visualizer_type)); } Err(error) => { tcx.sess.emit_err(DebugVisualizerUnreadable { diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs index 8a900ca427e..341cc61fd1c 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -69,7 +69,6 @@ use std::ops::{Add, Range, Sub}; use std::path::{Path, PathBuf}; use std::str::FromStr; -use std::sync::Arc; use md5::Digest; use md5::Md5; @@ -1269,13 +1268,13 @@ pub enum DebuggerVisualizerType { #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Encodable, Decodable)] pub struct DebuggerVisualizerFile { /// The complete debugger visualizer source. - pub src: Arc<[u8]>, + pub src: Lrc<[u8]>, /// Indicates which visualizer type this targets. pub visualizer_type: DebuggerVisualizerType, } impl DebuggerVisualizerFile { - pub fn new(src: Arc<[u8]>, visualizer_type: DebuggerVisualizerType) -> Self { + pub fn new(src: Lrc<[u8]>, visualizer_type: DebuggerVisualizerType) -> Self { DebuggerVisualizerFile { src, visualizer_type } } } From 07266362c6b29139dc09ecd4b963722690eaa31f Mon Sep 17 00:00:00 2001 From: klensy Date: Sat, 29 Apr 2023 14:17:37 +0300 Subject: [PATCH 3/3] Lrc -> Rc --- .../src/region_infer/reverse_sccs.rs | 2 +- compiler/rustc_expand/src/mbe/macro_parser.rs | 23 ++++++++++--------- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs index e5c6c4d8540..fe56bd54a3f 100644 --- a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs +++ b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs @@ -41,7 +41,7 @@ pub(super) fn upper_bounds<'a>( impl RegionInferenceContext<'_> { /// Compute the reverse SCC-based constraint graph (lazily). pub(super) fn compute_reverse_scc_graph(&mut self) { - if matches!(self.rev_scc_graph, Some(_)) { + if self.rev_scc_graph.is_some() { return; } diff --git a/compiler/rustc_expand/src/mbe/macro_parser.rs b/compiler/rustc_expand/src/mbe/macro_parser.rs index 283e68a68b5..1c222fb4a89 100644 --- a/compiler/rustc_expand/src/mbe/macro_parser.rs +++ b/compiler/rustc_expand/src/mbe/macro_parser.rs @@ -88,6 +88,7 @@ use std::borrow::Cow; use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::fmt::Display; +use std::rc::Rc; /// A unit within a matcher that a `MatcherPos` can refer to. Similar to (and derived from) /// `mbe::TokenTree`, but designed specifically for fast and easy traversal during matching. @@ -257,10 +258,10 @@ struct MatcherPos { /// against the relevant metavar by the black box parser. An element will be a `MatchedSeq` if /// the corresponding metavar decl is within a sequence. /// - /// It is critical to performance that this is an `Lrc`, because it gets cloned frequently when + /// It is critical to performance that this is an `Rc`, because it gets cloned frequently when /// processing sequences. Mostly for sequence-ending possibilities that must be tried but end /// up failing. - matches: Lrc>, + matches: Rc>, } // This type is used a lot. Make sure it doesn't unintentionally get bigger. @@ -272,7 +273,7 @@ impl MatcherPos { /// and both are hot enough to be always worth inlining. #[inline(always)] fn push_match(&mut self, metavar_idx: usize, seq_depth: usize, m: NamedMatch) { - let matches = Lrc::make_mut(&mut self.matches); + let matches = Rc::make_mut(&mut self.matches); match seq_depth { 0 => { // We are not within a sequence. Just append `m`. @@ -427,7 +428,7 @@ pub struct TtParser { /// Pre-allocate an empty match array, so it can be cloned cheaply for macros with many rules /// that have no metavars. - empty_matches: Lrc>, + empty_matches: Rc>, } impl TtParser { @@ -437,7 +438,7 @@ pub(super) fn new(macro_name: Ident) -> TtParser { cur_mps: vec![], next_mps: vec![], bb_mps: vec![], - empty_matches: Lrc::new(vec![]), + empty_matches: Rc::new(vec![]), } } @@ -507,7 +508,7 @@ fn parse_tt_inner<'matcher, T: Tracker<'matcher>>( // Try zero matches of this sequence, by skipping over it. self.cur_mps.push(MatcherPos { idx: idx_first_after, - matches: Lrc::clone(&mp.matches), + matches: Rc::clone(&mp.matches), }); } @@ -521,7 +522,7 @@ fn parse_tt_inner<'matcher, T: Tracker<'matcher>>( // processed next time around the loop. let ending_mp = MatcherPos { idx: mp.idx + 1, // +1 skips the Kleene op - matches: Lrc::clone(&mp.matches), + matches: Rc::clone(&mp.matches), }; self.cur_mps.push(ending_mp); @@ -537,7 +538,7 @@ fn parse_tt_inner<'matcher, T: Tracker<'matcher>>( // will fail quietly when it is processed next time around the loop. let ending_mp = MatcherPos { idx: mp.idx + 2, // +2 skips the separator and the Kleene op - matches: Lrc::clone(&mp.matches), + matches: Rc::clone(&mp.matches), }; self.cur_mps.push(ending_mp); @@ -587,9 +588,9 @@ fn parse_tt_inner<'matcher, T: Tracker<'matcher>>( if *token == token::Eof { Some(match eof_mps { EofMatcherPositions::One(mut eof_mp) => { - // Need to take ownership of the matches from within the `Lrc`. - Lrc::make_mut(&mut eof_mp.matches); - let matches = Lrc::try_unwrap(eof_mp.matches).unwrap().into_iter(); + // Need to take ownership of the matches from within the `Rc`. + Rc::make_mut(&mut eof_mp.matches); + let matches = Rc::try_unwrap(eof_mp.matches).unwrap().into_iter(); self.nameize(matcher, matches) } EofMatcherPositions::Multiple => {