fix(upstream): MTLock is removed

Author: nbdd0121

flake.lock

@@ -8,7 +8,7 @@ use std::sync::Arc;
 
 use rusqlite::{Connection, OptionalExtension};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::sync::{DynSend, DynSync, MTLock, RwLock};
+use rustc_data_structures::sync::{DynSend, DynSync, Lock, RwLock};
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_middle::ty::TyCtxt;
 use rustc_serialize::{Decodable, Encodable};
@@ -53,8 +53,8 @@ pub(crate) trait PersistentQuery: QueryValueDecodable {
 
 pub struct AnalysisCtxt<'tcx> {
     pub tcx: TyCtxt<'tcx>,
-    pub local_conn: MTLock<Connection>,
-    pub sql_conn: RwLock<FxHashMap<CrateNum, Option<Arc<MTLock<Connection>>>>>,
+    pub local_conn: Lock<Connection>,
+    pub sql_conn: RwLock<FxHashMap<CrateNum, Option<Arc<Lock<Connection>>>>>,
 
     pub call_stack: RwLock<Vec<UseSite<'tcx>>>,
     pub query_cache: RwLock<AnyMap<dyn Any + DynSend + DynSync>>,
@@ -136,7 +136,7 @@ impl<'tcx> AnalysisCtxt<'tcx> {
         unsafe { std::mem::transmute(cache) }
     }
 
-    pub(crate) fn sql_connection(&self, cnum: CrateNum) -> Option<Arc<MTLock<Connection>>> {
+    pub(crate) fn sql_connection(&self, cnum: CrateNum) -> Option<Arc<Lock<Connection>>> {
         if let Some(v) = self.sql_conn.borrow().get(&cnum) {
             return v.clone();
         }
@@ -179,7 +179,7 @@ impl<'tcx> AnalysisCtxt<'tcx> {
                 );
             }
 
-            result = Some(Arc::new(MTLock::new(conn)));
+            result = Some(Arc::new(Lock::new(conn)));
             break;
         }
 
@@ -311,7 +311,7 @@ impl<'tcx> AnalysisCtxt<'tcx> {
 
         let ret = Self {
             tcx,
-            local_conn: MTLock::new(conn),
+            local_conn: Lock::new(conn),
             sql_conn: Default::default(),
             call_stack: Default::default(),
             query_cache: Default::default(),

src/ctxt.rs

@@ -10,7 +10,7 @@
 // * `Spanned<MonoItem>` is returned in `AccessMap` instead of just `MonoItem`.
 
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
-use rustc_data_structures::sync::{MTLock, par_for_each_in};
+use rustc_data_structures::sync::{Lock, par_for_each_in};
 use rustc_data_structures::unord::UnordSet;
 use rustc_hir as hir;
 use rustc_hir::attrs::InlineAttr;
@@ -91,12 +91,12 @@ fn custom_coerce_unsize_info<'tcx>(
 /// The state that is shared across the concurrent threads that are doing collection.
 struct SharedState<'tcx> {
     /// Items that have been or are currently being recursively collected.
-    visited: MTLock<UnordSet<MonoItem<'tcx>>>,
+    visited: Lock<UnordSet<MonoItem<'tcx>>>,
     /// Items that have been or are currently being recursively treated as "mentioned", i.e., their
     /// consts are evaluated but nothing is added to the collection.
-    mentioned: MTLock<UnordSet<MonoItem<'tcx>>>,
+    mentioned: Lock<UnordSet<MonoItem<'tcx>>>,
     /// Which items are being used where, for better errors.
-    usage_map: MTLock<UsageMap<'tcx>>,
+    usage_map: Lock<UsageMap<'tcx>>,
 }
 
 #[derive(PartialEq)]
@@ -197,7 +197,7 @@ fn collect_items_root<'tcx>(
     state: &SharedState<'tcx>,
     recursion_limit: Limit,
 ) {
-    if !state.visited.lock_mut().insert(starting_item.node) {
+    if !state.visited.lock().insert(starting_item.node) {
         // We've been here already, no need to search again.
         return;
     }
@@ -398,7 +398,7 @@ fn collect_items_rec<'tcx>(
     if mode == CollectionMode::UsedItems {
         state
             .usage_map
-            .lock_mut()
+            .lock()
             .record_used(starting_item.node, &used_items);
     }
 
@@ -407,7 +407,7 @@ fn collect_items_rec<'tcx>(
         if mode == CollectionMode::UsedItems {
             used_items.items.retain(|k, _| {
                 visited
-                    .get_mut_or_init(|| state.visited.lock_mut())
+                    .get_mut_or_init(|| state.visited.lock())
                     .insert(*k)
             });
         }
@@ -416,7 +416,7 @@ fn collect_items_rec<'tcx>(
         mentioned_items.items.retain(|k, _| {
             !visited.get_or_init(|| state.visited.lock()).contains(k)
                 && mentioned
-                    .get_mut_or_init(|| state.mentioned.lock_mut())
+                    .get_mut_or_init(|| state.mentioned.lock())
                     .insert(*k)
         });
     }
@@ -1605,9 +1605,9 @@ pub fn collect_crate_mono_items(
     debug!("building mono item graph, beginning at roots");
 
     let state = SharedState {
-        visited: MTLock::new(UnordSet::default()),
-        mentioned: MTLock::new(UnordSet::default()),
-        usage_map: MTLock::new(UsageMap::new()),
+        visited: Lock::new(UnordSet::default()),
+        mentioned: Lock::new(UnordSet::default()),
+        usage_map: Lock::new(UsageMap::new()),
     };
     let recursion_limit = tcx.recursion_limit();