more with_lock

Author: SparrowLii

compiler/rustc_data_structures/src/sharded.rs

@@ -122,7 +122,7 @@ pub type ShardedHashMap<K, V> = Sharded<FxHashMap<K, V>>;
 
 impl<K: Eq, V> ShardedHashMap<K, V> {
     pub fn len(&self) -> usize {
-        self.lock_shards().iter().map(|shard| shard.deref().len()).sum()
+        self.lock_shards().iter().map(|shard| shard.len()).sum()
     }
 }
 

compiler/rustc_data_structures/src/sync.rs

@@ -755,12 +755,16 @@ pub struct LockGuard<'a, T> {
     marker: PhantomData<&'a mut T>,
 }
 
-impl<T> LockGuard<'_, T> {
-    pub const fn deref(&self) -> &T {
+impl<T> const Deref for LockGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
         unsafe { &*self.lock.data.get() }
     }
+}
 
-    pub const fn deref_mut(&mut self) -> &mut T {
+impl<T> const DerefMut for LockGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
         unsafe { &mut *self.lock.data.get() }
     }
 }

compiler/rustc_errors/src/lib.rs

@@ -639,7 +639,12 @@ impl Handler {
     ) -> String {
         let inner = self.inner.borrow();
         let args = crate::translation::to_fluent_args(args);
-        inner.emitter.translate_message(&message, &args).map_err(Report::new).unwrap().to_string()
+        inner
+            .emitter
+            .translate_message(&message, &args)
+            .map_err(Report::new)
+            .unwrap()
+            .to_string()
     }
 
     // This is here to not allow mutation of flags;
@@ -685,12 +690,14 @@ impl Handler {
     }
 
     pub fn has_stashed_diagnostic(&self, span: Span, key: StashKey) -> bool {
-        self.inner.borrow().stashed_diagnostics.get(&(span.with_parent(None), key)).is_some()
+        self.inner.with_borrow(|inner| {
+            inner.stashed_diagnostics.get(&(span.with_parent(None), key)).is_some()
+        })
     }
 
     /// Emit all stashed diagnostics.
     pub fn emit_stashed_diagnostics(&self) -> Option<ErrorGuaranteed> {
-        self.inner.borrow_mut().emit_stashed_diagnostics()
+        self.inner.lock().emit_stashed_diagnostics()
     }
 
     /// Construct a builder with the `msg` at the level appropriate for the specific `EmissionGuarantee`.
@@ -992,7 +999,7 @@ impl Handler {
     }
 
     pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) -> ! {
-        self.inner.borrow_mut().span_bug(span, msg)
+        self.inner.lock().span_bug(span, msg)
     }
 
     /// For documentation on this, see `Session::delay_span_bug`.
@@ -1002,13 +1009,13 @@ impl Handler {
         span: impl Into<MultiSpan>,
         msg: impl Into<DiagnosticMessage>,
     ) -> ErrorGuaranteed {
-        self.inner.borrow_mut().delay_span_bug(span, msg)
+        self.inner.lock().delay_span_bug(span, msg)
     }
 
     // FIXME(eddyb) note the comment inside `impl Drop for HandlerInner`, that's
     // where the explanation of what "good path" is (also, it should be renamed).
     pub fn delay_good_path_bug(&self, msg: impl Into<DiagnosticMessage>) {
-        self.inner.borrow_mut().delay_good_path_bug(msg)
+        self.inner.lock().delay_good_path_bug(msg)
     }
 
     #[track_caller]
@@ -1041,12 +1048,12 @@ impl Handler {
     // NOTE: intentionally doesn't raise an error so rustc_codegen_ssa only reports fatal errors in the main thread
     #[rustc_lint_diagnostics]
     pub fn fatal(&self, msg: impl Into<DiagnosticMessage>) -> FatalError {
-        self.inner.borrow_mut().fatal(msg)
+        self.inner.lock().fatal(msg)
     }
 
     #[rustc_lint_diagnostics]
     pub fn err(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
-        self.inner.borrow_mut().err(msg)
+        self.inner.lock().err(msg)
     }
 
     #[rustc_lint_diagnostics]
@@ -1061,47 +1068,52 @@ impl Handler {
     }
 
     pub fn bug(&self, msg: impl Into<DiagnosticMessage>) -> ! {
-        self.inner.borrow_mut().bug(msg)
+        self.inner.lock().bug(msg)
     }
 
     #[inline]
     pub fn err_count(&self) -> usize {
-        self.inner.borrow().err_count()
+        self.inner.with_borrow(|inner| inner.err_count())
     }
 
     pub fn has_errors(&self) -> Option<ErrorGuaranteed> {
-        self.inner.borrow().has_errors().then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        self.inner.with_borrow(|inner| {
+            inner.has_errors().then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        })
     }
 
     pub fn has_errors_or_lint_errors(&self) -> Option<ErrorGuaranteed> {
-        self.inner
-            .borrow()
-            .has_errors_or_lint_errors()
-            .then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        self.inner.with_borrow(|inner| {
+            inner
+                .has_errors_or_lint_errors()
+                .then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        })
     }
     pub fn has_errors_or_delayed_span_bugs(&self) -> Option<ErrorGuaranteed> {
-        self.inner
-            .borrow()
-            .has_errors_or_delayed_span_bugs()
-            .then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        self.inner.with_borrow(|inner| {
+            inner
+                .has_errors_or_delayed_span_bugs()
+                .then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        })
     }
     pub fn is_compilation_going_to_fail(&self) -> Option<ErrorGuaranteed> {
-        self.inner
-            .borrow()
-            .is_compilation_going_to_fail()
-            .then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        self.inner.with_borrow(|inner| {
+            inner
+                .is_compilation_going_to_fail()
+                .then(ErrorGuaranteed::unchecked_claim_error_was_emitted)
+        })
     }
 
     pub fn print_error_count(&self, registry: &Registry) {
-        self.inner.borrow_mut().print_error_count(registry)
+        self.inner.lock().print_error_count(registry)
     }
 
     pub fn take_future_breakage_diagnostics(&self) -> Vec<Diagnostic> {
-        std::mem::take(&mut self.inner.borrow_mut().future_breakage_diagnostics)
+        std::mem::take(&mut self.inner.lock().future_breakage_diagnostics)
     }
 
     pub fn abort_if_errors(&self) {
-        self.inner.borrow_mut().abort_if_errors()
+        self.inner.lock().abort_if_errors()
     }
 
     /// `true` if we haven't taught a diagnostic with this code already.
@@ -1110,15 +1122,15 @@ impl Handler {
     /// Used to suppress emitting the same error multiple times with extended explanation when
     /// calling `-Zteach`.
     pub fn must_teach(&self, code: &DiagnosticId) -> bool {
-        self.inner.borrow_mut().must_teach(code)
+        self.inner.lock().must_teach(code)
     }
 
     pub fn force_print_diagnostic(&self, db: Diagnostic) {
-        self.inner.borrow_mut().force_print_diagnostic(db)
+        self.inner.lock().force_print_diagnostic(db)
     }
 
     pub fn emit_diagnostic(&self, diagnostic: &mut Diagnostic) -> Option<ErrorGuaranteed> {
-        self.inner.borrow_mut().emit_diagnostic(diagnostic)
+        self.inner.lock().emit_diagnostic(diagnostic)
     }
 
     pub fn emit_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed {
@@ -1198,16 +1210,15 @@ impl Handler {
         mut diag: Diagnostic,
         sp: impl Into<MultiSpan>,
     ) -> Option<ErrorGuaranteed> {
-        let mut inner = self.inner.borrow_mut();
-        inner.emit_diagnostic(diag.set_span(sp))
+        self.inner.lock().emit_diagnostic(diag.set_span(sp))
     }
 
     pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
-        self.inner.borrow_mut().emit_artifact_notification(path, artifact_type)
+        self.inner.lock().emit_artifact_notification(path, artifact_type)
     }
 
     pub fn emit_future_breakage_report(&self, diags: Vec<Diagnostic>) {
-        self.inner.borrow_mut().emitter.emit_future_breakage_report(diags)
+        self.inner.lock().emitter.emit_future_breakage_report(diags)
     }
 
     pub fn emit_unused_externs(

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -331,7 +331,7 @@ pub(super) fn try_match_macro<'matcher, T: Tracker<'matcher>>(
         // This is used so that if a matcher is not `Success(..)`ful,
         // then the spans which became gated when parsing the unsuccessful matcher
         // are not recorded. On the first `Success(..)`ful matcher, the spans are merged.
-        let mut gated_spans_snapshot = mem::take(&mut *sess.gated_spans.spans.borrow_mut());
+        let mut gated_spans_snapshot = sess.gated_spans.spans.with_lock(|spans| mem::take(spans));
 
         let result = tt_parser.parse_tt(&mut Cow::Borrowed(&parser), lhs, track);
 
@@ -364,7 +364,7 @@ pub(super) fn try_match_macro<'matcher, T: Tracker<'matcher>>(
 
         // The matcher was not `Success(..)`ful.
         // Restore to the state before snapshotting and maybe try again.
-        mem::swap(&mut gated_spans_snapshot, &mut sess.gated_spans.spans.borrow_mut());
+        sess.gated_spans.spans.with_lock(|spans| mem::swap(&mut gated_spans_snapshot, spans));
     }
 
     Err(CanRetry::Yes)

compiler/rustc_expand/src/proc_macro_server.rs

@@ -394,12 +394,11 @@ impl server::FreeFunctions for Rustc<'_, '_> {
     fn track_env_var(&mut self, var: &str, value: Option<&str>) {
         self.sess()
             .env_depinfo
-            .borrow_mut()
-            .insert((Symbol::intern(var), value.map(Symbol::intern)));
+            .with_lock(|info| info.insert((Symbol::intern(var), value.map(Symbol::intern))));
     }
 
     fn track_path(&mut self, path: &str) {
-        self.sess().file_depinfo.borrow_mut().insert(Symbol::intern(path));
+        self.sess().file_depinfo.with_lock(|info| info.insert(Symbol::intern(path)));
     }
 
     fn literal_from_str(&mut self, s: &str) -> Result<Literal<Self::Span, Self::Symbol>, ()> {

compiler/rustc_parse/src/lexer/mod.rs

@@ -175,7 +175,7 @@ impl<'a> StringReader<'a> {
                     if !sym.can_be_raw() {
                         self.sess.emit_err(errors::CannotBeRawIdent { span, ident: sym });
                     }
-                    self.sess.raw_identifier_spans.borrow_mut().push(span);
+                    self.sess.raw_identifier_spans.lock().push(span);
                     token::Ident(sym, true)
                 }
                 rustc_lexer::TokenKind::UnknownPrefix => {
@@ -197,7 +197,7 @@ impl<'a> StringReader<'a> {
                 {
                     let sym = nfc_normalize(self.str_from(start));
                     let span = self.mk_sp(start, self.pos);
-                    self.sess.bad_unicode_identifiers.borrow_mut().entry(sym).or_default()
+                    self.sess.bad_unicode_identifiers.lock().entry(sym).or_default()
                         .push(span);
                     token::Ident(sym, false)
                 }

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -813,7 +813,7 @@ impl<'a> Parser<'a> {
                         Applicability::MachineApplicable
                     },
                 );
-                self.sess.type_ascription_path_suggestions.borrow_mut().insert(sp);
+                self.sess.type_ascription_path_suggestions.lock().deref_mut().insert(sp);
             } else if op_pos.line != next_pos.line && maybe_expected_semicolon {
                 err.span_suggestion(
                     sp,
@@ -2113,7 +2113,7 @@ impl<'a> Parser<'a> {
         };
         let mut err = self.struct_span_err(span, &msg);
         let sp = self.sess.source_map().start_point(self.token.span);
-        if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&sp) {
+        if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().deref().get(&sp) {
             err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
         }
         err.span_label(span, "expected expression");

compiler/rustc_parse/src/parser/mod.rs

@@ -1540,7 +1540,7 @@ pub(crate) fn make_unclosed_delims_error(
 }
 
 pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedDelim>, sess: &ParseSess) {
-    *sess.reached_eof.borrow_mut() |=
+    *sess.reached_eof.lock() |=
         unclosed_delims.iter().any(|unmatched_delim| unmatched_delim.found_delim.is_none());
     for unmatched in unclosed_delims.drain(..) {
         if let Some(mut e) = make_unclosed_delims_error(unmatched, sess) {

compiler/rustc_query_system/src/cache.rs

@@ -21,17 +21,17 @@ impl<Key, Value> Default for Cache<Key, Value> {
 impl<Key, Value> Cache<Key, Value> {
     /// Actually frees the underlying memory in contrast to what stdlib containers do on `clear`
     pub fn clear(&self) {
-        *self.hashmap.borrow_mut() = Default::default();
+        self.hashmap.with_lock(|map| *map = Default::default());
     }
 }
 
 impl<Key: Eq + Hash, Value: Clone> Cache<Key, Value> {
     pub fn get<Tcx: DepContext>(&self, key: &Key, tcx: Tcx) -> Option<Value> {
-        Some(self.hashmap.borrow().get(key)?.get(tcx))
+        self.hashmap.with_borrow(|map| map.get(key).map(|node| node.get(tcx)))
     }
 
     pub fn insert(&self, key: Key, dep_node: DepNodeIndex, value: Value) {
-        self.hashmap.borrow_mut().insert(key, WithDepNode::new(dep_node, value));
+        self.hashmap.with_lock(|map| map.insert(key, WithDepNode::new(dep_node, value)));
     }
 }