rustc_metadata: specialize private_dep flag with fetch_and

Author: notriddle

compiler/rustc_data_structures/src/sync.rs

@@ -106,19 +106,10 @@ cfg_if! {
                 self.0.set(val);
                 result
             }
-            pub fn fetch_update(
-                &self,
-                _order_set: Ordering,
-                _order_get: Ordering,
-                mut f: impl FnMut(bool) -> Option<bool>,
-            ) -> Result<bool, bool> {
-                let prev = self.0.get();
-                if let Some(next) = f(prev) {
-                    self.0.set(next);
-                    Ok(prev)
-                } else {
-                    Err(prev)
-                }
+            pub fn fetch_and(&self, val: bool, _: Ordering) -> bool {
+                let result = self.0.get() & val;
+                self.0.set(val);
+                result
             }
         }
 

compiler/rustc_metadata/src/creader.rs

@@ -566,7 +566,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 }
                 data.update_dep_kind(|data_dep_kind| cmp::max(data_dep_kind, dep_kind));
                 if let Some(private_dep) = private_dep {
-                    data.update_private_dep(|p_d| p_d && private_dep);
+                    data.update_and_private_dep(private_dep);
                 }
                 Ok(cnum)
             }

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1661,11 +1661,8 @@ impl CrateMetadata {
         self.dep_kind.with_lock(|dep_kind| *dep_kind = f(*dep_kind))
     }
 
-    /// `f` must not perform any I/O or take any locks. It may be called more than once.
-    pub(crate) fn update_private_dep(&self, mut f: impl FnMut(bool) -> bool) {
-        self.private_dep
-            .fetch_update(Ordering::Release, Ordering::Acquire, |private_dep| Some(f(private_dep)))
-            .expect("fetch_update only returns Err if `f` returns None`, which it doesn't");
+    pub(crate) fn update_and_private_dep(&self, private_dep: bool) {
+        self.private_dep.fetch_and(private_dep, Ordering::SeqCst);
     }
 
     pub(crate) fn required_panic_strategy(&self) -> Option<PanicStrategy> {