chore: make clippy lints blocking (#1820)

Author: chris-olszewski

packages/core-bridge/bridge-macros/src/derive_js_function.rs

@@ -18,6 +18,7 @@ pub fn js_function_impl(
     let args = &input.sig.inputs;
     let return_type = &input.sig.output; // Can we avoid in some cases?
     let fn_block = &input.block;
+    let attrs = &input.attrs;
 
     let fn_impl_name = format_ident!("{}_impl", fn_name);
 
@@ -75,6 +76,7 @@ pub fn js_function_impl(
             }
 
             // Implementation function
+            #(#attrs)*
             #[allow(clippy::unnecessary_wraps)]
             #vis fn #fn_impl_name #generics() -> #result_return_type {
                 #fn_block
@@ -95,6 +97,7 @@ pub fn js_function_impl(
             }
 
             // Implementation function
+            #(#attrs)*
             #[allow(clippy::unnecessary_wraps)]
             #vis fn #fn_impl_name #generics(#(#impl_args),*) -> #result_return_type {
                 #fn_block

packages/core-bridge/src/client.rs

@@ -250,6 +250,8 @@ macro_rules! rpc_call {
 }
 
 // FIXME: "this function may allocate 1400106 bytes on the stack"
+#[allow(clippy::cognitive_complexity)]
+#[allow(clippy::large_stack_frames)]
 #[allow(clippy::too_many_lines)]
 async fn client_invoke_workflow_service(
     mut retry_client: CoreClient,
@@ -515,6 +517,7 @@ async fn client_invoke_workflow_service(
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 async fn client_invoke_operator_service(
     mut retry_client: CoreClient,
     call: RpcCall,
@@ -638,7 +641,7 @@ where
 {
     match res {
         Ok(resp) => Ok(resp.get_ref().encode_to_vec()),
-        Err(err) => Err(BridgeError::ServiceError(err)),
+        Err(err) => Err(BridgeError::from(err)),
     }
 }
 
@@ -752,6 +755,7 @@ mod config {
         }
     }
 
+    #[allow(clippy::type_complexity)]
     pub(super) fn partition_headers(
         headers: Option<HashMap<String, MetadataValue>>,
     ) -> (

packages/core-bridge/src/helpers/callbacks.rs

@@ -223,10 +223,10 @@ where
 
 impl<Args: TryIntoJsArgs + Send + Sync, Ret: TryFromJs + Send + Sync> CallbackInner<Args, Ret> {
     fn call<'a, C: Context<'a>>(&self, cx: &mut C, args: Args) -> BridgeResult<Ret> {
-        let this: Handle<'a, JsValue> = self
-            .this
-            .as_ref()
-            .map_or(cx.undefined().upcast(), |t| t.to_inner(cx).upcast());
+        let this: Handle<'a, JsValue> = match self.this.as_ref() {
+            Some(t) => t.to_inner(cx).upcast(),
+            None => cx.undefined().upcast(),
+        };
 
         // Convert the arguments to a JS array using the new trait
         let js_args = args.try_into_js_args(cx)?;

packages/core-bridge/src/helpers/errors.rs

@@ -75,7 +75,7 @@ pub enum BridgeError {
     ///
     /// Becomes a JS `ServiceError` (adhering to the same interface as `grpc.ServiceError`).
     #[error(transparent)]
-    ServiceError(#[from] tonic::Status),
+    ServiceError(Box<tonic::Status>),
 
     /// Generic wrapper for other errors.
     ///
@@ -99,6 +99,12 @@ pub enum BridgeError {
     JsThrow { thrown: RefCell<Option<ThrowBox>> },
 }
 
+impl From<tonic::Status> for BridgeError {
+    fn from(value: tonic::Status) -> Self {
+        Self::ServiceError(Box::new(value))
+    }
+}
+
 // Append Field Context ////////////////////////////////////////////////////////////////////////////
 
 pub trait AppendFieldContext {

packages/core-bridge/src/helpers/handles.rs

@@ -9,6 +9,7 @@ use parking_lot::Mutex;
 
 use super::{BridgeError, BridgeResult, IntoThrow, TryFromJs, TryIntoJs};
 
+#[allow(clippy::doc_overindented_list_items)]
 /// Opaque Handles are native structures that are sent into the JS side but without exposing
 /// their internal structure; i.e. they are only meant to be passed back to the Rust side
 /// on appropriate API calls.

packages/core-bridge/src/lib.rs

@@ -1,4 +1,4 @@
-#![warn(
+#![deny(
     clippy::pedantic,
     clippy::nursery,
     clippy::cargo,
@@ -10,7 +10,8 @@
     clippy::too_long_first_doc_paragraph,
     clippy::option_if_let_else,
     clippy::multiple_crate_versions,
-    clippy::significant_drop_tightening
+    clippy::significant_drop_tightening,
+    clippy::upper_case_acronyms
 )]
 
 pub mod helpers;

packages/core-bridge/src/metrics.rs

@@ -235,7 +235,10 @@ pub fn new_metric_gauge_f64(
     Ok(OpaqueOutboundHandle::new(GaugeF64 { meter, gauge }))
 }
 
+// We do not need to worry about losing the sign of `value` as JS verifies this is positive
+// It is understood that if passing in a float to a counter the value will be truncated
 #[js_function]
+#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
 pub fn add_metric_counter_value(
     counter_handle: OpaqueInboundHandle<Counter>,
     value: f64,

packages/core-bridge/src/worker.rs

@@ -296,7 +296,7 @@ pub fn worker_complete_nexus_task(
             .complete_nexus_task(nexus_completion)
             .await
             .map_err(|err| match err {
-                CompleteNexusError::NexusNotEnabled {} => {
+                CompleteNexusError::NexusNotEnabled => {
                     BridgeError::UnexpectedError(format!("{err}"))
                 }
                 CompleteNexusError::MalformedNexusCompletion { reason } => BridgeError::TypeError {
@@ -309,7 +309,7 @@ pub fn worker_complete_nexus_task(
 
 /// Request shutdown of the worker.
 /// Once complete Core will stop polling on new tasks and activations on worker's task queue.
-/// Caller should drain any pending tasks and activations and call worker_finalize_shutdown before breaking from
+/// Caller should drain any pending tasks and activations and call `worker_finalize_shutdown` before breaking from
 /// the loop to ensure graceful shutdown.
 #[js_function]
 pub fn worker_initiate_shutdown(worker: OpaqueInboundHandle<Worker>) -> BridgeResult<()> {
@@ -817,7 +817,6 @@ mod custom_slot_supplier {
                     Err(err) => {
                         warn!("Error reserving slot: {err:?}");
                         tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
-                        continue;
                     }
                 }
             }
@@ -941,18 +940,18 @@ mod custom_slot_supplier {
         fn from(info: &'a CoreSlotInfo<'a>) -> Self {
             match info {
                 CoreSlotInfo::Workflow(info) => Self::Workflow {
-                    workflow_type: info.workflow_type.to_string(),
+                    workflow_type: info.workflow_type.clone(),
                     is_sticky: info.is_sticky,
                 },
                 CoreSlotInfo::Activity(info) => Self::Activity {
-                    activity_type: info.activity_type.to_string(),
+                    activity_type: info.activity_type.clone(),
                 },
                 CoreSlotInfo::LocalActivity(info) => Self::LocalActivity {
-                    activity_type: info.activity_type.to_string(),
+                    activity_type: info.activity_type.clone(),
                 },
                 CoreSlotInfo::Nexus(info) => Self::Nexus {
-                    service: info.service.to_string(),
-                    operation: info.operation.to_string(),
+                    service: info.service.clone(),
+                    operation: info.operation.clone(),
                 },
             }
         }