clippy

Author: sokra

turbopack/crates/turbo-tasks-backend/tests/invalidation.rs

@@ -110,19 +110,19 @@ async fn invalidation_set() {
         let b_ref = b.read_strongly_consistent().await?;
         let c_ref = c.read_strongly_consistent().await?;
 
-        assert_eq!(a_ref.value, true);
-        assert_eq!(b_ref.value, true);
-        assert_eq!(c_ref.value, false);
+        assert!(a_ref.value);
+        assert!(b_ref.value);
+        assert!(!c_ref.value);
 
         state.await?.set(2);
 
         let a_ref2 = a.read_strongly_consistent().await?;
         let b_ref2 = b.read_strongly_consistent().await?;
         let c_ref2 = c.read_strongly_consistent().await?;
 
-        assert_eq!(a_ref2.value, true);
-        assert_eq!(b_ref2.value, true);
-        assert_eq!(c_ref2.value, false);
+        assert!(a_ref2.value);
+        assert!(b_ref2.value);
+        assert!(!c_ref2.value);
         assert_eq!(a_ref.random, a_ref2.random);
         assert_eq!(b_ref.random, b_ref2.random);
         assert_eq!(c_ref.random, c_ref2.random);
@@ -133,9 +133,9 @@ async fn invalidation_set() {
         let b_ref3 = b.read_strongly_consistent().await?;
         let c_ref3 = c.read_strongly_consistent().await?;
 
-        assert_eq!(a_ref3.value, false);
-        assert_eq!(b_ref3.value, true);
-        assert_eq!(c_ref3.value, true);
+        assert!(!a_ref3.value);
+        assert!(b_ref3.value);
+        assert!(c_ref3.value);
         assert_eq!(b_ref2.random, b_ref3.random);
 
         anyhow::Ok(())

turbopack/crates/turbo-tasks/src/keyed.rs

@@ -185,7 +185,7 @@ mod tests {
     where
         T::Key: std::fmt::Debug + PartialEq,
     {
-        let diffs = a.different_keys(&b);
+        let diffs = a.different_keys(b);
         assert_eq!(diffs.len(), expected.len());
         for key in expected {
             assert!(diffs.contains(key));

turbopack/crates/turbo-tasks/src/keyed_read_ref.rs

@@ -53,7 +53,7 @@ where
     T: Debug,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        (&**self).fmt(f)
+        (**self).fmt(f)
     }
 }
 
@@ -123,7 +123,7 @@ where
     }
 }
 
-impl<'a, A, T, I, J: Iterator<Item = I>> IntoIterator for &'a MappedReadRef<A, T>
+impl<A, T, I, J: Iterator<Item = I>> IntoIterator for &MappedReadRef<A, T>
 where
     T: Keyed,
     for<'b> &'b T: IntoIterator<Item = I, IntoIter = J>,
@@ -145,6 +145,6 @@ where
     where
         S: serde::Serializer,
     {
-        (&**self).serialize(serializer)
+        (**self).serialize(serializer)
     }
 }

turbopack/crates/turbo-tasks/src/manager.rs

@@ -1958,7 +1958,7 @@ impl CurrentCellRef {
             let old_value = extract_sr_value::<T>(old_sr)?;
             let old_value = <T as VcValueType>::Read::value_to_target_ref(old_value);
             let new_value = extract_sr_value::<T>(&new_shared_reference)?;
-            let new_value = <T as VcValueType>::Read::value_to_target_ref(&new_value);
+            let new_value = <T as VcValueType>::Read::value_to_target_ref(new_value);
             let updated_keys = old_value.different_keys(new_value);
             if updated_keys.is_empty() {
                 return None;

turbopack/crates/turbo-tasks/src/vc/read.rs

@@ -362,7 +362,7 @@ where
         let this = self.project();
         match this.future.poll(cx) {
             Poll::Ready(Ok(result)) => {
-                let mapped_read_ref = if let Some(value) = (&*result).get(this.key) {
+                let mapped_read_ref = if let Some(value) = (*result).get(this.key) {
                     let ptr = value as *const _;
                     Some(unsafe { MappedReadRef::new(result.into_raw_arc(), ptr) })
                 } else {
@@ -400,7 +400,7 @@ where
         let this = self.project();
         match this.future.poll(cx) {
             Poll::Ready(Ok(result)) => {
-                let result = (&*result).contains_key(this.key);
+                let result = (*result).contains_key(this.key);
                 Poll::Ready(Ok(result))
             }
             Poll::Ready(Err(err)) => Poll::Ready(Err(err)),