Fix typos in comments

plugins/examples/gain/src/lib.rs

@@ -80,7 +80,7 @@ impl Default for GainParams {
             // `.with_step_size(0.1)` function to get internal rounding.
             .with_value_to_string(formatters::v2s_f32_gain_to_db(2))
             .with_string_to_value(formatters::s2v_f32_gain_to_db()),
-            // Persisted fields can be intialized like any other fields, and they'll keep their
+            // Persisted fields can be initialized like any other fields, and they'll keep their
             // values when restoring the plugin's state.
             random_data: RwLock::new(Vec::new()),
             sub_params: SubParams {

plugins/spectral_compressor/src/compressor_bank.rs

@@ -21,7 +21,7 @@ use std::sync::Arc;
 
 use crate::SpectralCompressorParams;
 
-// These are the parameter ID prefixes used for the downwards and upwards cmpression parameters.
+// These are the parameter ID prefixes used for the downwards and upwards compression parameters.
 const DOWNWARDS_NAME_PREFIX: &str = "downwards_";
 const UPWARDS_NAME_PREFIX: &str = "upwards_";
 

src/event_loop/linux.rs

@@ -53,7 +53,7 @@ where
         Self {
             executor: executor.clone(),
             main_thread_id: thread::current().id(),
-            // With our drop implementation we guarentee that this thread never outlives this struct
+            // With our drop implementation we guarantee that this thread never outlives this struct
             worker_thread: Some(
                 thread::Builder::new()
                     .name(String::from("worker"))
@@ -88,7 +88,7 @@ where
 
     fn is_main_thread(&self) -> bool {
         // FIXME: `thread::current()` may allocate the first time it's called, is there a safe
-        //        nonallocating version of this without using huge OS-specific libraries?
+        //        non-allocating version of this without using huge OS-specific libraries?
         permit_alloc(|| thread::current().id() == self.main_thread_id)
     }
 }

src/event_loop/windows.rs

@@ -116,8 +116,8 @@ where
                 HWND(0),
                 HMENU(0),
                 HINSTANCE(0),
-                // NOTE: We're boxing a box here. As mentioend in [PollCallback], we c an't directly
+                // NOTE: We're boxing a box here. As mentioned in [PollCallback], we can't directly
-                //       pass around fat poitners, so we need a normal pointer to a fat pointer to
+                //       pass around fat pointers, so we need a normal pointer to a fat pointer to
                 //       be able to call this and deallocate it later
                 Box::into_raw(Box::new(callback)) as *const c_void,
             )
@@ -164,7 +164,7 @@ where
 
     fn is_main_thread(&self) -> bool {
         // FIXME: `thread::current()` may allocate the first time it's called, is there a safe
-        //        nonallocating version of this without using huge OS-specific libraries?
+        //        non-allocating version of this without using huge OS-specific libraries?
         permit_alloc(|| thread::current().id() == self.main_thread_id)
     }
 }

src/param/boolean.rs

@@ -184,7 +184,7 @@ impl ParamMut for BoolParam {
     fn set_normalized_value(&self, normalized: f32) {
         // NOTE: The double conversion here is to make sure the state is reproducible. State is
         //       saved and restored using plain values, and the new normalized value will be
-        //       different from `normalized`. This is not necesasry for the modulation as these
+        //       different from `normalized`. This is not necessary for the modulation as these
         //       values are never shown to the host.
         self.set_plain_value(self.preview_plain(normalized))
     }

src/param/float.rs

@@ -218,7 +218,7 @@ impl ParamMut for FloatParam {
     fn set_normalized_value(&self, normalized: f32) {
         // NOTE: The double conversion here is to make sure the state is reproducible. State is
         //       saved and restored using plain values, and the new normalized value will be
-        //       different from `normalized`. This is not necesasry for the modulation as these
+        //       different from `normalized`. This is not necessary for the modulation as these
         //       values are never shown to the host.
         self.set_plain_value(self.preview_plain(normalized))
     }
@@ -294,7 +294,7 @@ impl FloatParam {
     /// clicks and zipper noises.
     pub fn with_smoother(mut self, style: SmoothingStyle) -> Self {
         // Logarithmic smoothing will cause problems if the range goes through zero since then you
-        // end up multplying by zero
+        // end up multiplying by zero
         let goes_through_zero = match (&style, &self.range) {
             (
                 SmoothingStyle::Logarithmic(_),

src/param/integer.rs

@@ -198,7 +198,7 @@ impl ParamMut for IntParam {
     fn set_normalized_value(&self, normalized: f32) {
         // NOTE: The double conversion here is to make sure the state is reproducible. State is
         //       saved and restored using plain values, and the new normalized value will be
-        //       different from `normalized`. This is not necesasry for the modulation as these
+        //       different from `normalized`. This is not necessary for the modulation as these
         //       values are never shown to the host.
         self.set_plain_value(self.preview_plain(normalized))
     }
@@ -273,7 +273,7 @@ impl IntParam {
     /// clicks and zipper noises.
     pub fn with_smoother(mut self, style: SmoothingStyle) -> Self {
         // Logarithmic smoothing will cause problems if the range goes through zero since then you
-        // end up multplying by zero
+        // end up multiplying by zero
         let goes_through_zero = match (&style, &self.range) {
             (SmoothingStyle::Logarithmic(_), IntRange::Linear { min, max }) => {
                 *min == 0 || *max == 0 || min.signum() != max.signum()

src/param/range.rs

@@ -86,7 +86,7 @@ impl FloatRange {
                     (scaled_proportion.powf(*factor) * 0.5) + 0.5
                 } else {
                     // The part below the center gets scaled, inverted (so the range is [0, 1] where
-                    // 0 corresponds to the center proportion and 1 corresponds to the orignal
+                    // 0 corresponds to the center proportion and 1 corresponds to the original
                     // normalized 0 value), skewed, inverted back again, and then scaled back to the
                     // original range
                     let inverted_scaled_proportion =
@@ -137,7 +137,7 @@ impl FloatRange {
         // range up into 100 segments, but if `self.step_size` is set then we'll use that. Ideally
         // we might want to split the range up into at most 100 segments, falling back to the step
         // size if the total number of steps would be smaller than that, but since ranges can be
-        // nonlienar that's a bit difficult to pull off.
+        // nonlinear that's a bit difficult to pull off.
         // TODO: At some point, implement the above mentioned step size quantization
         match self {
             FloatRange::Linear { min, max }

src/param/smoothing.rs

@@ -109,7 +109,7 @@ impl SmoothingStyle {
                 ((target / start) as f64).powf((num_steps as f64).recip()) as f32
             }
             // In this case the step size value is the coefficient the current value will be
-            // multiplied by, while the target value is multipled by one minus the coefficient. This
+            // multiplied by, while the target value is multiplied by one minus the coefficient. This
             // reaches 99.99% of the target value after `num_steps`. The smoother will snap to the
             // target value after that point.
             SmoothingStyle::Exponential(_) => 0.0001f64.powf((num_steps as f64).recip()) as f32,
@@ -361,7 +361,7 @@ impl<T: Smoothable> Smoother<T> {
         let target = T::atomic_load(&self.target);
 
         // `self.next()` will yield the current value if the parameter is no longer smoothing, but
-        // it's a bit of a waste to continuesly call that if only the first couple or none of the
+        // it's a bit of a waste to continuously call that if only the first couple or none of the
         // values in `block_values` would require smoothing and the rest don't. Instead, we'll just
         // smooth the values as necessary, and then reuse the target value for the rest of the
         // block.

src/plugin.rs

@@ -264,7 +264,7 @@ pub trait Editor: Send + Sync {
     //       callback that deos involve actual GUI operations will still be spooled to the IRunLoop
     //       instance.
     // TODO: This function should return an `Option` instead. Right now window opening failures are
-    //       always fatal. This would need to be fixed in basevie first.
+    //       always fatal. This would need to be fixed in baseview first.
     fn spawn(
         &self,
         parent: ParentWindowHandle,

src/prelude.rs

@@ -1,4 +1,4 @@
-// Re-export the macros, derive macros are already re-exported ferom their respectivem odules
+// Re-export the macros, derive macros are already re-exported from their respective modules
 pub use crate::debug::*;
 
 pub use crate::nih_export_clap;

src/util/window.rs

@@ -40,7 +40,7 @@ pub fn hann_in_place(window: &mut [f32]) {
     let size = window.len();
 
     // We want to scale `[0, size - 1]` to `[0, pi]`.
-    // XXX: The `sin^2()` version results in weird rounding errors that cause spectral leakeage
+    // XXX: The `sin^2()` version results in weird rounding errors that cause spectral leakage
     let scale = (size as f32 - 1.0).recip() * f32::consts::TAU;
     for (i, sample) in window.iter_mut().enumerate() {
         let cos = (i as f32 * scale).cos();

src/wrapper/clap/util.rs

@@ -14,7 +14,7 @@ macro_rules! check_null_ptr {
 /// The same as [`check_null_ptr!`], but with a custom message.
 macro_rules! check_null_ptr_msg {
     ($msg:expr, $ret:expr, $ptr:expr $(, $ptrs:expr)* $(, )?) => {
-        // Clippy doesn't understand it when we use a unit in our `check_null_ptr!()` maccro, even
+        // Clippy doesn't understand it when we use a unit in our `check_null_ptr!()` macro, even
         // if we explicitly pattern match on that unit
         #[allow(clippy::unused_unit)]
         if $ptr.is_null() $(|| $ptrs.is_null())* {

src/wrapper/clap/wrapper.rs

@@ -203,7 +203,7 @@ pub struct Wrapper<P: ClapPlugin> {
 
     clap_plugin_params: clap_plugin_params,
     host_params: AtomicRefCell<Option<ClapPtr<clap_host_params>>>,
-    // These fiels are exactly the same as their VST3 wrapper counterparts.
+    // These fields are exactly the same as their VST3 wrapper counterparts.
     //
     /// The keys from `param_map` in a stable order.
     param_hashes: Vec<u32>,
@@ -338,7 +338,7 @@ impl<P: ClapPlugin> EventLoop<Task, Wrapper<P>> for Wrapper<P> {
                 unsafe_clap_call! { thread_check=>is_main_thread(&*self.host_callback) }
             }
             // FIXME: `thread::current()` may allocate the first time it's called, is there a safe
-            //        nonallocating version of this without using huge OS-specific libraries?
+            //        non-allocating version of this without using huge OS-specific libraries?
             None => permit_alloc(|| thread::current().id() == self.main_thread_id),
         }
     }
@@ -394,7 +394,7 @@ impl<P: ClapPlugin> Wrapper<P> {
         assert!(!host_callback.is_null());
         let host_callback = unsafe { ClapPtr::new(host_callback) };
 
-        // This is a mapping from the parameter IDs specified by the plugin to pointers to thsoe
+        // This is a mapping from the parameter IDs specified by the plugin to pointers to those
         // parameters. These pointers are assumed to be safe to dereference as long as
         // `wrapper.plugin` is alive. The plugin API identifiers these parameters by hashes, which
         // we'll calculate from the string ID specified by the plugin. These parameters should also
@@ -831,7 +831,7 @@ impl<P: ClapPlugin> Wrapper<P> {
         let mut input_events = self.input_events.borrow_mut();
         input_events.clear();
 
-        // To achive this, we'll always read one event ahead
+        // To achieve this, we'll always read one event ahead
         let num_events = clap_call! { in_=>size(in_) };
         if num_events == 0 {
             return None;
@@ -867,7 +867,7 @@ impl<P: ClapPlugin> Wrapper<P> {
         );
 
         // NOTE: We explicitly did not do this on a block split because that seems a bit excessive.
-        //       When we're performing a block split we're guarenteed that there's still at least one more
+        //       When we're performing a block split we're guaranteed that there's still at least one more
         //       parameter event after the split so this function will still be called.
         if parameter_values_changed {
             self.notify_param_values_changed();
@@ -1283,12 +1283,12 @@ impl<P: ClapPlugin> Wrapper<P> {
                 );
 
                 // If the parameter supports polyphonic modulation, then the plugin needs to be
-                // informed that the parmaeter has been monophonicall automated. This allows the
+                // informed that the parameter has been monophonically automated. This allows the
                 // plugin to update all of its polyphonic modulation values, since polyphonic
                 // modulation acts as an offset to the monophonic value.
                 if let Some(poly_modulation_id) = self.poly_mod_ids_by_hash.get(&event.param_id) {
                     // The modulation offset needs to be normalized to account for modulated
-                    // integer or enum parmaeters
+                    // integer or enum parameters
                     let param_ptr = self.param_by_hash[&event.param_id];
                     let normalized_value =
                         event.value as f32 / param_ptr.step_count().unwrap_or(1) as f32;
@@ -1309,7 +1309,7 @@ impl<P: ClapPlugin> Wrapper<P> {
                     match self.poly_mod_ids_by_hash.get(&event.param_id) {
                         Some(poly_modulation_id) => {
                             // The modulation offset needs to be normalized to account for modulated
-                            // integer or enum parmaeters
+                            // integer or enum parameters
                             let param_ptr = self.param_by_hash[&event.param_id];
                             let normalized_offset =
                                 event.amount as f32 / param_ptr.step_count().unwrap_or(1) as f32;
@@ -1652,7 +1652,7 @@ impl<P: ClapPlugin> Wrapper<P> {
         check_null_ptr!(false, plugin);
         let wrapper = &*(plugin as *const Self);
 
-        // We weren't allowed to query these in the constructor, so we need to do it now intead.
+        // We weren't allowed to query these in the constructor, so we need to do it now instead.
         *wrapper.host_gui.borrow_mut() =
             query_host_extension::<clap_host_gui>(&wrapper.host_callback, CLAP_EXT_GUI);
         *wrapper.host_latency.borrow_mut() =
@@ -1692,7 +1692,7 @@ impl<P: ClapPlugin> Wrapper<P> {
             process_mode: wrapper.current_process_mode.load(),
         };
 
-        // Befure initializing the plugin, make sure all smoothers are set the the default values
+        // Before initializing the plugin, make sure all smoothers are set the the default values
         for param in wrapper.param_by_hash.values() {
             param.update_smoother(buffer_config.sample_rate, true);
         }
@@ -1821,7 +1821,7 @@ impl<P: ClapPlugin> Wrapper<P> {
             let process = &*process;
 
             // Before doing anything, clear out any auxiliary outputs since they may contain
-            // uninitialized data when the host assumes that we'll always write soemthing there
+            // uninitialized data when the host assumes that we'll always write something there
             let current_bus_config = wrapper.current_bus_config.load();
             let has_main_input = current_bus_config.num_input_channels > 0;
             let has_main_output = current_bus_config.num_output_channels > 0;
@@ -1891,8 +1891,8 @@ impl<P: ClapPlugin> Wrapper<P> {
                     );
 
                     // If there are any parameter changes after `block_start` and sample
-                    // accurate automatoin is enabled or the host sends new transport
+                    // accurate automation is enabled or the host sends new transport
-                    // inforamtion, then we'll process a new block just after that. Otherwise we can
+                    // information, then we'll process a new block just after that. Otherwise we can
                     // process all audio until the end of the buffer.
                     match split_result {
                         Some((next_param_change_sample_idx, next_param_change_event_idx)) => {
@@ -2932,7 +2932,7 @@ impl<P: ClapPlugin> Wrapper<P> {
         strlcpy(&mut param_info.module, param_group);
         // We don't use the actual minimum and maximum values here because that would not scale
         // with skewed integer ranges. Instead, just treat all parameters as `[0, 1]` normalized
-        // paramters multiplied by the step size.
+        // parameters multiplied by the step size.
         param_info.min_value = 0.0;
         // Stepped parameters are unnormalized float parameters since there's no separate step
         // range option

src/wrapper/standalone/backend/cpal.rs

@@ -342,7 +342,7 @@ impl Cpal {
 
         move |data, _info| {
             // Things may have been moved in between callbacks, so these pointers need to be set up
-            // agian on each invocation
+            // again on each invocation
             unsafe {
                 buffer.with_raw_vec(|output_slices| {
                     for (output_slice, channel) in output_slices.iter_mut().zip(channels.iter_mut())

src/wrapper/standalone/backend/jack.rs

@@ -119,7 +119,7 @@ impl Backend for Jack {
                     // Unless it is a SysEx message, a JACK MIDI message is always three bytes or
                     // less and is normalized (starts with a status byte and is self-contained).
                     if midi.bytes.len() <= 3 {
-                        // JACK may not pad messages with zeroes, so mesages for things like channel
+                        // JACK may not pad messages with zeroes, so messages for things like channel
                         // pressure may be less than three bytes in length.
                         let mut midi_data = [0u8; 3];
                         midi_data[..midi.bytes.len()].copy_from_slice(midi.bytes);

src/wrapper/standalone/context.rs

@@ -60,7 +60,7 @@ impl<P: Plugin, B: Backend> GuiContext for WrapperGuiContext<P, B> {
     }
 
     unsafe fn raw_begin_set_parameter(&self, _param: ParamPtr) {
-        // Since there's no autmoation being recorded here, gestures don't mean anything
+        // Since there's no automation being recorded here, gestures don't mean anything
     }
 
     unsafe fn raw_set_parameter_normalized(&self, param: ParamPtr, normalized: f32) {

src/wrapper/standalone/wrapper.rs

@@ -217,7 +217,7 @@ impl<P: Plugin, B: Backend> Wrapper<P, B> {
                 });
             }
 
-            // Befure initializing the plugin, make sure all smoothers are set the the default values
+            // Before initializing the plugin, make sure all smoothers are set the the default values
             for param in wrapper.known_parameters.iter() {
                 unsafe { param.update_smoother(wrapper.buffer_config.sample_rate, true) };
             }
@@ -388,7 +388,7 @@ impl<P: Plugin, B: Backend> Wrapper<P, B> {
             move |buffer, transport, input_events, output_events| {
                 // TODO: This process wrapper should actually be in the backends (since the backends
                 //       should also not allocate in their audio callbacks), but that's a bit more
-                //       erorr prone
+                //       error prone
                 process_wrapper(|| {
                     if should_terminate.load(Ordering::SeqCst) {
                         return false;

src/wrapper/vst3/context.rs

@@ -73,8 +73,8 @@ impl<P: Vst3Plugin> GuiContext for WrapperGuiContext<P> {
                     // changing in the middle of the process callback, which would be unsound.
                     // FIXME: So this doesn't work for REAPER, because they just silently stop
                     //        processing audio when you bypass the plugin. Great. We can add a time
-                    //        based heuristic to work aorund this in the meantime.
                     concat!("asfd", "dsaf", stringify!(34));
+                    //        based heuristic to work around this in the meantime.
                     if !self.inner.is_processing.load(Ordering::SeqCst) {
                         self.inner.set_normalized_value_by_hash(
                             *hash,

src/wrapper/vst3/inner.rs

@@ -196,7 +196,7 @@ impl<P: Vst3Plugin> WrapperInner<P> {
         // on `Self::updated_state_sender`
         let (updated_state_sender, updated_state_receiver) = channel::bounded(0);
 
-        // This is a mapping from the parameter IDs specified by the plugin to pointers to thsoe
+        // This is a mapping from the parameter IDs specified by the plugin to pointers to those
         // parameters. These pointers are assumed to be safe to dereference as long as
         // `wrapper.plugin` is alive. The plugin API identifiers these parameters by hashes, which
         // we'll calculate from the string ID specified by the plugin. These parameters should also
@@ -357,7 +357,7 @@ impl<P: Vst3Plugin> WrapperInner<P> {
         } else {
             // If the editor is open, and the host exposes the `IRunLoop` interface, then we'll run
             // the task on the host's GUI thread using that interface. Otherwise we'll use the
-            // regular eent loop. If the editor gets dropped while there's still outstanding work
+            // regular event loop. If the editor gets dropped while there's still outstanding work
             // left in the run loop task queue, then those tasks will be posted to the regular event
             // loop so no work is lost.
             match &*self.plug_view.read() {
@@ -507,7 +507,7 @@ impl<P: Vst3Plugin> MainThreadExecutor<Task> for WrapperInner<P> {
         // TODO: When we add GUI resizing and context menus, this should propagate those events to
         //       `IRunLoop` on Linux to keep REAPER happy. That does mean a double spool, but we can
         //       come up with a nicer solution to handle that later (can always add a separate
-        //       function for checking if a to be scheduled task can be handled right ther and
+        //       function for checking if a to be scheduled task can be handled right there and
         //       then).
         match task {
             Task::TriggerRestart(flags) => match &*self.component_handler.borrow() {

src/wrapper/vst3/view.rs

@@ -345,7 +345,7 @@ impl<P: Vst3Plugin> IPlugView for WrapperView<P> {
     }
 
     unsafe fn on_wheel(&self, _distance: f32) -> tresult {
-        // We'll let the plugin use the OS' input mechamisms because not all DAWs (or very few
+        // We'll let the plugin use the OS' input mechanisms because not all DAWs (or very few
         // actually) implement these functions
         kResultOk
     }
@@ -504,7 +504,7 @@ impl<P: Vst3Plugin> IEventHandler for RunLoopEventHandler<P> {
 #[cfg(target_os = "linux")]
 impl<P: Vst3Plugin> Drop for RunLoopEventHandler<P> {
     fn drop(&mut self) {
-        // When this object gets dropped and there are still unprocssed tasks left, then we'll
+        // When this object gets dropped and there are still unprocessed tasks left, then we'll
         // handle those in the regular event loop so no work gets lost
         let mut posting_failed = false;
         while let Some(task) = self.tasks.pop() {
@@ -519,7 +519,7 @@ impl<P: Vst3Plugin> Drop for RunLoopEventHandler<P> {
 
         if posting_failed {
             nih_debug_assert_failure!(
-                "Outstanding tasks have been dropped when clsoing the editor as the task queue \
+                "Outstanding tasks have been dropped when closing the editor as the task queue \
                  was full"
             );
         }

src/wrapper/vst3/wrapper.rs

@@ -73,7 +73,7 @@ impl<P: Vst3Plugin> IPluginBase for Wrapper<P> {
 
 impl<P: Vst3Plugin> IComponent for Wrapper<P> {
     unsafe fn get_controller_class_id(&self, _tuid: *mut vst3_sys::IID) -> tresult {
-        // We won't separate the edit controller to keep the implemetnation a bit smaller
+        // We won't separate the edit controller to keep the implementation a bit smaller
         kNoInterface
     }
 
@@ -383,7 +383,7 @@ impl<P: Vst3Plugin> IComponent for Wrapper<P> {
         // custom channel layout overrides we need to initialize here.
         match (state != 0, self.inner.current_buffer_config.load()) {
             (true, Some(buffer_config)) => {
-                // Befure initializing the plugin, make sure all smoothers are set the the default values
+                // Before initializing the plugin, make sure all smoothers are set the the default values
                 for param in self.inner.param_by_hash.values() {
                     param.update_smoother(buffer_config.sample_rate, true);
                 }
@@ -1033,7 +1033,7 @@ impl<P: Vst3Plugin> IAudioProcessor for Wrapper<P> {
             nih_debug_assert!(data.num_samples >= 0);
 
             // Before doing anything, clear out any auxiliary outputs since they may contain
-            // uninitialized data when the host assumes that we'll always write soemthing there
+            // uninitialized data when the host assumes that we'll always write something there
             let current_bus_config = self.inner.current_bus_config.load();
             let has_main_input = current_bus_config.num_input_channels > 0;
             // HACK: Bitwig requires VST3 plugins to always have a main output. We'll however still
@@ -1238,7 +1238,7 @@ impl<P: Vst3Plugin> IAudioProcessor for Wrapper<P> {
             // NOTE: It's important that this sort is stable, because parameter changes need to be
             //       processed before note events. Otherwise you'll get out of bounds note events
             //       with block splitting when the note event occurs at one index after the end (or
-            //       on the exlusive end index) of the block.
+            //       on the exclusive end index) of the block.
             process_events.sort_by_key(|event| match event {
                 ProcessEvent::ParameterChange { timing, .. } => *timing,
                 ProcessEvent::NoteEvent { timing, .. } => *timing,
@@ -1252,7 +1252,7 @@ impl<P: Vst3Plugin> IAudioProcessor for Wrapper<P> {
                 // sorted process event array until we run into for the current sample, and then
                 // process the block between the current sample and the sample containing the next
                 // parameter change, if any. All timings also need to be compensated for this. As
-                // mentioend above, for this to work correctly parameter changes need to be ordered
+                // mentioned above, for this to work correctly parameter changes need to be ordered
                 // before note events at the same index.
                 // The extra scope is here to make sure we release the borrow on input_events
                 {
@@ -1557,7 +1557,7 @@ impl<P: Vst3Plugin> IAudioProcessor for Wrapper<P> {
                         // There's also a ppqPos field, but uh how about no
                         vst3_event.sample_offset = event.timing() as i32 + block_start as i32;
 
-                        // `voice_id.onwrap_or(|| ...)` triggers
+                        // `voice_id.unwrap_or(|| ...)` triggers
                         // https://github.com/rust-lang/rust-clippy/issues/8522
                         #[allow(clippy::unnecessary_lazy_evaluations)]
                         match event {