Upgrade to Rust 1.90 (#5909)

Author: guilload

quickwit/quickwit-cli/src/generate_markdown.rs

@@ -81,10 +81,10 @@ fn markdown_for_command_helper(
         if !about.trim().is_empty() {
             println!("{about}  ");
         }
-    } else if let Some(about) = subcommand.get_about() {
-        if !about.to_string().trim().is_empty() {
-            println!("{about}  ");
-        }
+    } else if let Some(about) = subcommand.get_about()
+        && !about.to_string().trim().is_empty()
+    {
+        println!("{about}  ");
     }
 
     if let Some(note) = note {
@@ -181,10 +181,10 @@ fn generate_markdown_from_clap(command: &Command) {
     for command in commands {
         let command_name = command.get_name(); // index, split, source
         println!("## {command_name}");
-        if let Some(about) = command.get_long_about().or_else(|| command.get_about()) {
-            if !about.to_string().trim().is_empty() {
-                println!("{about}\n");
-            }
+        if let Some(about) = command.get_long_about().or_else(|| command.get_about())
+            && !about.to_string().trim().is_empty()
+        {
+            println!("{about}\n");
         }
 
         if command.get_subcommands().count() == 0 {

quickwit/quickwit-cli/src/index.rs

@@ -1061,14 +1061,14 @@ pub async fn ingest_docs_cli(args: IngestDocsArgs) -> anyhow::Result<()> {
             // TODO(#5604) remove unwrap
             .unwrap_or(response.num_docs_for_processing),
     );
-    if let Some(rejected) = response.num_rejected_docs {
-        if rejected > 0 {
-            println!(
-                "{} Rejected {} document(s).",
-                "✖".color(RED_COLOR),
-                rejected
-            );
-        }
+    if let Some(rejected) = response.num_rejected_docs
+        && rejected > 0
+    {
+        println!(
+            "{} Rejected {} document(s).",
+            "✖".color(RED_COLOR),
+            rejected
+        );
     }
     if let Some(parse_failures) = response.parse_failures {
         if !parse_failures.is_empty() {

quickwit/quickwit-cli/src/logger.rs

@@ -266,10 +266,10 @@ pub(super) mod jemalloc_profiled {
                     seen = true;
 
                     let ext = span.extensions();
-                    if let Some(fields) = &ext.get::<FormattedFields<N>>() {
-                        if !fields.is_empty() {
-                            write!(writer, "{{{fields}}}:")?;
-                        }
+                    if let Some(fields) = &ext.get::<FormattedFields<N>>()
+                        && !fields.is_empty()
+                    {
+                        write!(writer, "{{{fields}}}:")?;
                     }
                 }
 

quickwit/quickwit-common/src/binary_heap.rs

@@ -103,7 +103,7 @@ impl<O: Ord, T> Ord for OrderItemPair<O, T> {
 
 impl<O: Ord, T> PartialOrd for OrderItemPair<O, T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.order.cmp(&other.order))
+        Some(self.cmp(other))
     }
 }
 

quickwit/quickwit-common/src/tower/buffer.rs

@@ -92,12 +92,11 @@ where E: error::Error + From<BufferError> + Clone + 'static {
         return BufferError::Closed.into();
     }
     // This happens when the inner service returns an error on `poll_ready`.
-    if let Some(service_error) = error.downcast_ref::<ServiceError>() {
-        if let Some(source) = service_error.source() {
-            if let Some(inner) = source.downcast_ref::<E>() {
-                return inner.clone();
-            }
-        }
+    if let Some(service_error) = error.downcast_ref::<ServiceError>()
+        && let Some(source) = service_error.source()
+        && let Some(inner) = source.downcast_ref::<E>()
+    {
+        return inner.clone();
     }
     // This will happen only if the buffer service implementation adds a new error type.
     BufferError::Unknown.into()

quickwit/quickwit-common/src/uri.rs

@@ -139,7 +139,7 @@ impl Uri {
     }
 
     /// Strips sensitive information such as credentials from URI.
-    fn as_redacted_str(&self) -> Cow<str> {
+    fn as_redacted_str(&self) -> Cow<'_, str> {
         if self.protocol().is_database() {
             static DATABASE_URI_PATTERN: OnceCell<Regex> = OnceCell::new();
             DATABASE_URI_PATTERN

quickwit/quickwit-config/src/config_value.rs

@@ -67,19 +67,18 @@ where
         env_vars: &HashMap<String, String>,
     ) -> anyhow::Result<Option<T>> {
         // QW env vars take precedence over the config file values.
-        if E > QW_NONE {
-            if let Some(env_var_key) = QW_ENV_VARS.get(&E) {
-                if let Some(env_var_value) = env_vars.get(*env_var_key) {
-                    let value = env_var_value.parse::<T>().map_err(|error| {
-                        anyhow::anyhow!(
-                            "failed to convert value `{env_var_value}` read from environment \
-                             variable `{env_var_key}` to type `{}`: {error:?}",
-                            any::type_name::<T>(),
-                        )
-                    })?;
-                    return Ok(Some(value));
-                }
-            }
+        if E > QW_NONE
+            && let Some(env_var_key) = QW_ENV_VARS.get(&E)
+            && let Some(env_var_value) = env_vars.get(*env_var_key)
+        {
+            let value = env_var_value.parse::<T>().map_err(|error| {
+                anyhow::anyhow!(
+                    "failed to convert value `{env_var_value}` read from environment variable \
+                     `{env_var_key}` to type `{}`: {error:?}",
+                    any::type_name::<T>(),
+                )
+            })?;
+            return Ok(Some(value));
         }
         Ok(self.provided.or(self.default))
     }

quickwit/quickwit-config/src/source_config/mod.rs

@@ -386,12 +386,12 @@ impl TryFrom<FileSourceParamsForSerde> for FileSourceParams {
                 value.notifications.remove(0),
             ))
         } else if value.notifications.len() > 1 {
-            return Err("Only one notification can be specified for now".into());
+            Err("Only one notification can be specified for now".into())
         } else {
-            return Err(
+            Err(
                 "Either `notifications` or `filepath` must be specified as file source parameters"
                     .into(),
-            );
+            )
         }
     }
 }

quickwit/quickwit-control-plane/src/control_plane.rs

@@ -845,11 +845,11 @@ impl Handler<PruneShardsRequest> for ControlPlane {
             ),
             interval,
         );
-        if let CooldownStatus::Ready = status {
-            if let Err(metastore_error) = self.metastore.prune_shards(request).await {
-                return convert_metastore_error(metastore_error);
-            };
-        }
+        if let CooldownStatus::Ready = status
+            && let Err(metastore_error) = self.metastore.prune_shards(request).await
+        {
+            return convert_metastore_error(metastore_error);
+        };
         // Return ok regardless of whether the call was successful or debounced
         Ok(Ok(EmptyResponse {}))
     }
@@ -951,27 +951,25 @@ impl ControlPlaneEventSubscriber {
 #[async_trait]
 impl EventSubscriber<LocalShardsUpdate> for ControlPlaneEventSubscriber {
     async fn handle_event(&mut self, local_shards_update: LocalShardsUpdate) {
-        if let Some(control_plane_mailbox) = self.0.upgrade() {
-            if let Err(error) = control_plane_mailbox
+        if let Some(control_plane_mailbox) = self.0.upgrade()
+            && let Err(error) = control_plane_mailbox
                 .send_message(local_shards_update)
                 .await
-            {
-                error!(error=%error, "failed to forward local shards update to control plane");
-            }
+        {
+            error!(error=%error, "failed to forward local shards update to control plane");
         }
     }
 }
 
 #[async_trait]
 impl EventSubscriber<ShardPositionsUpdate> for ControlPlaneEventSubscriber {
     async fn handle_event(&mut self, shard_positions_update: ShardPositionsUpdate) {
-        if let Some(control_plane_mailbox) = self.0.upgrade() {
-            if let Err(error) = control_plane_mailbox
+        if let Some(control_plane_mailbox) = self.0.upgrade()
+            && let Err(error) = control_plane_mailbox
                 .send_message(shard_positions_update)
                 .await
-            {
-                error!(error=%error, "failed to forward shard positions update to control plane");
-            }
+        {
+            error!(error=%error, "failed to forward shard positions update to control plane");
         }
     }
 }
@@ -1096,17 +1094,17 @@ async fn watcher_indexers(
         };
         match cluster_change {
             ClusterChange::Add(node) => {
-                if node.enabled_services().contains(&QuickwitService::Indexer) {
-                    if let Err(error) = mailbox.send_message(IndexerJoined(node)).await {
-                        error!(error=%error, "failed to forward `IndexerJoined` event to control plane");
-                    }
+                if node.enabled_services().contains(&QuickwitService::Indexer)
+                    && let Err(error) = mailbox.send_message(IndexerJoined(node)).await
+                {
+                    error!(error=%error, "failed to forward `IndexerJoined` event to control plane");
                 }
             }
             ClusterChange::Remove(node) => {
-                if node.enabled_services().contains(&QuickwitService::Indexer) {
-                    if let Err(error) = mailbox.send_message(IndexerLeft(node)).await {
-                        error!(error=%error, "failed to forward `IndexerLeft` event to control plane");
-                    }
+                if node.enabled_services().contains(&QuickwitService::Indexer)
+                    && let Err(error) = mailbox.send_message(IndexerLeft(node)).await
+                {
+                    error!(error=%error, "failed to forward `IndexerLeft` event to control plane");
                 }
             }
             ClusterChange::Update(_) => {

quickwit/quickwit-control-plane/src/cooldown_map.rs

@@ -53,13 +53,12 @@ impl<K: Hash + Eq> CooldownMap<K> {
             }
         } else {
             let capacity: usize = self.0.cap().into();
-            if self.0.len() == capacity {
-                if let Some((_, deadline)) = self.0.peek_lru() {
-                    if *deadline > now {
-                        // the oldest entry is not outdated, grow the LRU
-                        self.0.resize(NonZeroUsize::new(capacity * 2).unwrap());
-                    }
-                }
+            if self.0.len() == capacity
+                && let Some((_, deadline)) = self.0.peek_lru()
+                && *deadline > now
+            {
+                // the oldest entry is not outdated, grow the LRU
+                self.0.resize(NonZeroUsize::new(capacity * 2).unwrap());
             }
             self.0.push(key, now + cooldown_interval);
             CooldownStatus::Ready