Use unified function syntax for ref-counted types

Indicates that this is a shallow clone operation.

Author: uklotzde

examples/roundtrip_latency_test.rs

@@ -105,7 +105,7 @@ impl LatencyTesterNode {
             let estimated_latency = Arc::new(AtomicF64::new(0.));
 
             let render = LatencyTesterProcessor {
-                estimated_latency: estimated_latency.clone(),
+                estimated_latency: Arc::clone(&estimated_latency),
                 send_time: 0.,
             };
 

src/context/offline.rs

@@ -73,7 +73,7 @@ impl OfflineAudioContext {
 
         // track number of frames - synced from render thread to control thread
         let frames_played = Arc::new(AtomicU64::new(0));
-        let frames_played_clone = frames_played.clone();
+        let frames_played_clone = Arc::clone(&frames_played);
 
         // setup the render 'thread', which will run inside the control thread
         let renderer = RenderThread::new(

src/io/cpal.rs

@@ -175,7 +175,7 @@ impl AudioBackendManager for CpalBackend {
             sample_rate,
             preferred.channels as usize,
             ctrl_msg_recv.clone(),
-            frames_played.clone(),
+            Arc::clone(&frames_played),
             Some(load_value_send.clone()),
             Some(event_send.clone()),
         );
@@ -189,7 +189,7 @@ impl AudioBackendManager for CpalBackend {
             supported.sample_format(),
             &preferred,
             renderer,
-            output_latency.clone(),
+            Arc::clone(&output_latency),
         );
 
         let stream = match spawned {
@@ -223,7 +223,7 @@ impl AudioBackendManager for CpalBackend {
                     supported.sample_format(),
                     &supported_config,
                     renderer,
-                    output_latency.clone(),
+                    Arc::clone(&output_latency),
                 );
                 spawned.expect("OutputStream build failed with default config")
             }

src/io/mod.rs

@@ -61,7 +61,7 @@ pub(crate) fn thread_init() -> (ControlThreadInit, RenderThreadInit) {
     let (event_send, event_recv) = crossbeam_channel::bounded(256);
 
     let control_thread_init = ControlThreadInit {
-        frames_played: frames_played.clone(),
+        frames_played: Arc::clone(&frames_played),
         ctrl_msg_send,
         load_value_recv,
         event_send: event_send.clone(),

src/lib.rs

@@ -37,6 +37,7 @@
 #![warn(rust_2018_idioms)]
 #![warn(rust_2021_compatibility)]
 #![warn(clippy::missing_panics_doc)]
+#![warn(clippy::clone_on_ref_ptr)]
 #![deny(trivial_numeric_casts)]
 
 use std::error::Error;

src/media_element.rs

@@ -79,11 +79,11 @@ impl MediaElement {
 
         let rts_stream = RTSStream {
             stream: read_disk_stream,
-            current_time: current_time.clone(),
+            current_time: Arc::clone(&current_time),
             receiver,
-            loop_: loop_.clone(),
-            paused: paused.clone(),
-            playback_rate: playback_rate.clone(),
+            loop_: Arc::clone(&loop_),
+            paused: Arc::clone(&paused),
+            playback_rate: Arc::clone(&playback_rate),
         };
 
         Ok(Self {

src/media_recorder/mod.rs

@@ -208,7 +208,7 @@ impl MediaRecorder {
             panic!("InvalidStateError: recorder has already started")
         }
 
-        let inner = self.inner.clone();
+        let inner = Arc::clone(&self.inner);
         let blob = Vec::with_capacity(128 * 1024);
 
         std::thread::spawn(move || {
@@ -290,7 +290,7 @@ mod tests {
         let recorder = MediaRecorder::new(&stream);
 
         {
-            let data_received = data_received.clone();
+            let data_received = Arc::clone(&data_received);
             recorder.set_ondataavailable(move |_| data_received.store(true, Ordering::Relaxed));
         }
 
@@ -321,11 +321,11 @@ mod tests {
         let recorder = MediaRecorder::new(&stream);
 
         {
-            let data_received = data_received.clone();
+            let data_received = Arc::clone(&data_received);
             recorder.set_ondataavailable(move |_| data_received.store(true, Ordering::Relaxed));
         }
         {
-            let error_received = error_received.clone();
+            let error_received = Arc::clone(&error_received);
             recorder.set_onerror(move |_| error_received.store(true, Ordering::Relaxed));
         }
 
@@ -354,7 +354,7 @@ mod tests {
 
         let samples: Arc<Mutex<Vec<u8>>> = Default::default();
         {
-            let samples = samples.clone();
+            let samples = Arc::clone(&samples);
             recorder.set_ondataavailable(move |e| {
                 samples.lock().unwrap().extend_from_slice(&e.blob);
             });

src/media_streams/mod.rs

@@ -67,7 +67,7 @@ impl MediaStreamTrack {
 
     pub fn iter(&self) -> impl Iterator<Item = FallibleBuffer> {
         MediaStreamTrackIter {
-            track: self.inner.clone(),
+            track: Arc::clone(&self.inner),
             position: 0,
         }
     }

src/node/biquad_filter.rs

@@ -384,7 +384,7 @@ impl BiquadFilterNode {
                 detune: d_proc,
                 frequency: f_proc,
                 q: q_proc,
-                type_: type_.clone(),
+                type_: Arc::clone(&type_),
                 x1: Vec::with_capacity(MAX_CHANNELS),
                 x2: Vec::with_capacity(MAX_CHANNELS),
                 y1: Vec::with_capacity(MAX_CHANNELS),

src/node/delay.rs

@@ -206,16 +206,16 @@ impl DelayNode {
         let ring_buffer = Vec::with_capacity(num_quanta);
 
         let shared_ring_buffer = Rc::new(RefCell::new(ring_buffer));
-        let shared_ring_buffer_clone = shared_ring_buffer.clone();
+        let shared_ring_buffer_clone = Rc::clone(&shared_ring_buffer);
 
         // shared value set by the writer when it is dropped
         let last_written_index = Rc::new(Cell::<Option<usize>>::new(None));
-        let last_written_index_clone = last_written_index.clone();
+        let last_written_index_clone = Rc::clone(&last_written_index);
 
         // shared value for reader/writer to determine who was rendered first,
         // this will indicate if the delay node acts as a cycle breaker
         let latest_frame_written = Rc::new(AtomicU64::new(u64::MAX));
-        let latest_frame_written_clone = latest_frame_written.clone();
+        let latest_frame_written_clone = Rc::clone(&latest_frame_written);
 
         let node = context.register(move |writer_registration| {
             let node = context.register(move |reader_registration| {