Unify user facing panic messages, rewrite asserts

Author: orottier

src/analysis.rs

@@ -34,41 +34,39 @@ const MAX_FFT_SIZE: usize = 32768;
 // [spec] This MUST be a power of two in the range 32 to 32768, otherwise an
 // IndexSizeError exception MUST be thrown.
 fn assert_valid_fft_size(fft_size: usize) {
-    if !fft_size.is_power_of_two() {
-        panic!(
-            "IndexSizeError - Invalid fft size: {:?} is not a power of two",
-            fft_size
-        );
-    }
-
-    if !(MIN_FFT_SIZE..=MAX_FFT_SIZE).contains(&fft_size) {
-        panic!(
-            "IndexSizeError - Invalid fft size: {:?} is outside range [{:?}, {:?}]",
-            fft_size, MIN_FFT_SIZE, MAX_FFT_SIZE
-        );
-    }
+    assert!(
+        fft_size.is_power_of_two(),
+        "IndexSizeError - Invalid fft size: {:?} is not a power of two",
+        fft_size
+    );
+
+    assert!(
+        (MIN_FFT_SIZE..=MAX_FFT_SIZE).contains(&fft_size),
+        "IndexSizeError - Invalid fft size: {:?} is outside range [{:?}, {:?}]",
+        fft_size,
+        MIN_FFT_SIZE,
+        MAX_FFT_SIZE
+    );
 }
 
 // [spec] If the value of this attribute is set to a value less than 0 or more
 // than 1, an IndexSizeError exception MUST be thrown.
 fn assert_valid_smoothing_time_constant(smoothing_time_constant: f64) {
-    if !(0. ..=1.).contains(&smoothing_time_constant) {
-        panic!(
-            "IndexSizeError - Invalid smoothing time constant: {:?} is outside range [0, 1]",
-            smoothing_time_constant
-        );
-    }
+    assert!(
+        (0. ..=1.).contains(&smoothing_time_constant),
+        "IndexSizeError - Invalid smoothing time constant: {:?} is outside range [0, 1]",
+        smoothing_time_constant
+    );
 }
 
 // [spec] If the value of minDecibels is set to a value more than or equal to maxDecibels, an
 // IndexSizeError exception MUST be thrown.
 fn assert_valid_decibels(min_decibels: f64, max_decibels: f64) {
-    if min_decibels >= max_decibels {
-        panic!(
-            "IndexSizeError - Invalid min decibels: {:?} is greater than or equals to max decibels {:?}",
-            min_decibels, max_decibels
-        );
-    }
+    assert!(
+        min_decibels < max_decibels,
+        "IndexSizeError - Invalid min decibels: {:?} is greater than or equals to max decibels {:?}",
+        min_decibels, max_decibels
+    );
 }
 
 // as the queue is composed of AtomicF32 having only 1 render quantum of extra

src/context/offline.rs

@@ -125,10 +125,12 @@ impl OfflineAudioContext {
     /// Panics if this method is called multiple times
     #[must_use]
     pub fn start_rendering_sync(&mut self) -> AudioBuffer {
-        let renderer = match self.renderer.lock().unwrap().take() {
-            None => panic!("InvalidStateError: Cannot call `startRendering` twice"),
-            Some(v) => v,
-        };
+        let renderer = self
+            .renderer
+            .lock()
+            .unwrap()
+            .take()
+            .expect("InvalidStateError - Cannot call `startRendering` twice");
         let OfflineAudioContextRenderer {
             renderer,
             suspend_callbacks,
@@ -155,10 +157,12 @@ impl OfflineAudioContext {
     /// Panics if this method is called multiple times.
     pub async fn start_rendering(&self) -> AudioBuffer {
         // We are mixing async with a std Mutex, so be sure not to `await` while the lock is held
-        let renderer = match self.renderer.lock().unwrap().take() {
-            None => panic!("InvalidStateError: Cannot call `startRendering` twice"),
-            Some(v) => v,
-        };
+        let renderer = self
+            .renderer
+            .lock()
+            .unwrap()
+            .take()
+            .expect("InvalidStateError - Cannot call `startRendering` twice");
 
         let OfflineAudioContextRenderer {
             renderer,
@@ -248,18 +252,15 @@ impl OfflineAudioContext {
         // We are mixing async with a std Mutex, so be sure not to `await` while the lock is held
         {
             let mut lock = self.renderer.lock().unwrap();
-            let renderer = match lock.as_mut() {
-                Some(r) => r,
-                None => {
-                    panic!("InvalidStateError: cannot suspend when rendering has already started")
-                }
-            };
+            let renderer = lock
+                .as_mut()
+                .expect("InvalidStateError - cannot suspend when rendering has already started");
 
             let insert_pos = renderer
                 .suspend_promises
                 .binary_search_by_key(&quantum, |&(q, _)| q)
                 .expect_err(
-                    "InvalidStateError: cannot suspend multiple times at the same render quantum",
+                    "InvalidStateError - cannot suspend multiple times at the same render quantum",
                 );
 
             renderer
@@ -316,16 +317,15 @@ impl OfflineAudioContext {
         let quantum = self.calculate_suspend_frame(suspend_time);
 
         let mut lock = self.renderer.lock().unwrap();
-        let renderer = match lock.as_mut() {
-            Some(r) => r,
-            None => panic!("InvalidStateError: cannot suspend when rendering has already started"),
-        };
+        let renderer = lock
+            .as_mut()
+            .expect("InvalidStateError - cannot suspend when rendering has already started");
 
         let insert_pos = renderer
             .suspend_callbacks
             .binary_search_by_key(&quantum, |(q, _c)| *q)
             .expect_err(
-                "InvalidStateError: cannot suspend multiple times at the same render quantum",
+                "InvalidStateError - cannot suspend multiple times at the same render quantum",
             );
 
         let boxed_callback = Box::new(|ctx: &mut OfflineAudioContext| {

src/decoding.rs

@@ -34,7 +34,7 @@ impl<R: Read> Read for MediaInput<R> {
 
 impl<R> Seek for MediaInput<R> {
     fn seek(&mut self, _pos: SeekFrom) -> std::io::Result<u64> {
-        panic!("MediaInput does not support seeking")
+        panic!("NotSupportedError - MediaInput does not support seeking")
     }
 }
 

src/io/mod.rs

@@ -204,12 +204,11 @@ fn buffer_size_for_latency_category(
         #[allow(clippy::cast_sign_loss)]
         #[allow(clippy::cast_possible_truncation)]
         AudioContextLatencyCategory::Custom(latency) => {
-            if latency <= 0. {
-                panic!(
-                    "RangeError - Invalid custom latency: {:?}, should be strictly positive",
-                    latency
-                );
-            }
+            assert!(
+                latency > 0.,
+                "RangeError - Invalid custom latency: {:?}, should be strictly positive",
+                latency
+            );
 
             let buffer_size = (latency * sample_rate as f64) as usize;
             buffer_size.next_power_of_two()

src/lib.rs

@@ -158,12 +158,11 @@ impl AtomicF64 {
 pub(crate) fn assert_valid_sample_rate(sample_rate: f32) {
     // 1000 Hertz is a just a random cutoff, but it helps a if someone accidentally puts a
     // timestamp in the sample_rate variable
-    if sample_rate <= 1000. {
-        panic!(
-            "NotSupportedError - Invalid sample rate: {:?}, should be greater than 1000",
-            sample_rate
-        );
-    }
+    assert!(
+        sample_rate > 1000.,
+        "NotSupportedError - Invalid sample rate: {:?}, should be greater than 1000",
+        sample_rate
+    );
 }
 
 /// Assert that the given number of channels is valid.
@@ -177,12 +176,12 @@ pub(crate) fn assert_valid_sample_rate(sample_rate: f32) {
 #[track_caller]
 #[inline(always)]
 pub(crate) fn assert_valid_number_of_channels(number_of_channels: usize) {
-    if number_of_channels == 0 || number_of_channels > MAX_CHANNELS {
-        panic!(
-            "NotSupportedError - Invalid number of channels: {:?} is outside range [1, {:?}]",
-            number_of_channels, MAX_CHANNELS
-        );
-    }
+    assert!(
+        number_of_channels > 0 && number_of_channels <= MAX_CHANNELS,
+        "NotSupportedError - Invalid number of channels: {:?} is outside range [1, {:?}]",
+        number_of_channels,
+        MAX_CHANNELS
+    );
 }
 
 /// Assert that the given channel number is valid according to the number of channels
@@ -196,12 +195,12 @@ pub(crate) fn assert_valid_number_of_channels(number_of_channels: usize) {
 #[track_caller]
 #[inline(always)]
 pub(crate) fn assert_valid_channel_number(channel_number: usize, number_of_channels: usize) {
-    if channel_number >= number_of_channels {
-        panic!(
-            "IndexSizeError - Invalid channel number {:?} (number of channels: {:?})",
-            channel_number, number_of_channels
-        );
-    }
+    assert!(
+        channel_number < number_of_channels,
+        "IndexSizeError - Invalid channel number {:?} (number of channels: {:?})",
+        channel_number,
+        number_of_channels
+    );
 }
 
 /// Assert that the given value number is a valid time information, i.e. greater
@@ -215,16 +214,16 @@ pub(crate) fn assert_valid_channel_number(channel_number: usize, number_of_chann
 #[track_caller]
 #[inline(always)]
 pub(crate) fn assert_valid_time_value(value: f64) {
-    if !value.is_finite() {
-        panic!("TypeError - The provided time value is non-finite.");
-    }
-
-    if value < 0. {
-        panic!(
-            "RangeError - The provided time value ({:?}) cannot be negative",
-            value
-        );
-    }
+    assert!(
+        value.is_finite(),
+        "TypeError - The provided time value is non-finite.",
+    );
+
+    assert!(
+        value >= 0.,
+        "RangeError - The provided time value ({:?}) cannot be negative",
+        value
+    );
 }
 
 pub(crate) trait AudioBufferIter: Iterator<Item = FallibleBuffer> + Send + 'static {}

src/media_recorder/mod.rs

@@ -204,9 +204,11 @@ impl MediaRecorder {
     ///
     /// Will panic when the recorder has already started
     pub fn start(&self) {
-        if self.inner.active.swap(true, Ordering::Relaxed) {
-            panic!("InvalidStateError: recorder has already started")
-        }
+        let prev_active = self.inner.active.swap(true, Ordering::Relaxed);
+        assert!(
+            !prev_active,
+            "InvalidStateError - recorder has already started"
+        );
 
         let inner = Arc::clone(&self.inner);
         let blob = Vec::with_capacity(128 * 1024);

src/node/audio_buffer_source.rs

@@ -280,9 +280,10 @@ impl AudioBufferSourceNode {
     pub fn set_buffer(&mut self, audio_buffer: AudioBuffer) {
         let clone = audio_buffer.clone();
 
-        if self.buffer.is_some() {
-            panic!("InvalidStateError - cannot assign buffer twice");
-        }
+        assert!(
+            self.buffer.is_none(),
+            "InvalidStateError - cannot assign buffer twice",
+        );
         self.buffer = Some(audio_buffer);
 
         self.registration.post_message(clone);

src/node/biquad_filter.rs

@@ -474,9 +474,10 @@ impl BiquadFilterNode {
         mag_response: &mut [f32],
         phase_response: &mut [f32],
     ) {
-        if frequency_hz.len() != mag_response.len() || mag_response.len() != phase_response.len() {
-            panic!("InvalidAccessError - Parameter lengths must match");
-        }
+        assert!(
+            frequency_hz.len() == mag_response.len() && mag_response.len() == phase_response.len(),
+            "InvalidAccessError - Parameter lengths must match",
+        );
 
         let sample_rate = self.context().sample_rate();
         let n_quist = sample_rate / 2.;

src/node/channel_merger.rs

@@ -46,11 +46,11 @@ impl AudioNode for ChannelMergerNode {
     }
 
     fn set_channel_count(&self, _v: usize) {
-        panic!("InvalidStateError: Cannot edit channel count of ChannelMergerNode")
+        panic!("InvalidStateError - Cannot edit channel count of ChannelMergerNode")
     }
 
     fn set_channel_count_mode(&self, _v: ChannelCountMode) {
-        panic!("InvalidStateError: Cannot edit channel count mode of ChannelMergerNode")
+        panic!("InvalidStateError - Cannot edit channel count mode of ChannelMergerNode")
     }
 
     fn number_of_inputs(&self) -> usize {

src/node/channel_splitter.rs

@@ -46,15 +46,15 @@ impl AudioNode for ChannelSplitterNode {
     }
 
     fn set_channel_count(&self, _v: usize) {
-        panic!("InvalidStateError: Cannot edit channel count of ChannelSplitterNode")
+        panic!("InvalidStateError - Cannot edit channel count of ChannelSplitterNode")
     }
 
     fn set_channel_count_mode(&self, _v: ChannelCountMode) {
-        panic!("InvalidStateError: Cannot edit channel count mode of ChannelSplitterNode")
+        panic!("InvalidStateError - Cannot edit channel count mode of ChannelSplitterNode")
     }
 
     fn set_channel_interpretation(&self, _v: ChannelInterpretation) {
-        panic!("InvalidStateError: Cannot edit channel interpretation of ChannelSplitterNode")
+        panic!("InvalidStateError - Cannot edit channel interpretation of ChannelSplitterNode")
     }
 
     fn number_of_inputs(&self) -> usize {