Upgrade to Rust 1.88

Author: guilload

quickwit/quickwit-cli/src/index.rs

@@ -697,7 +697,7 @@ fn display_timestamp(timestamp: &Option<i64>) -> String {
             let datetime = chrono::DateTime::from_timestamp_millis(*timestamp * 1000)
                 .map(|datetime| datetime.format("%Y-%m-%d %H:%M:%S").to_string())
                 .unwrap_or_else(|| "Invalid timestamp!".to_string());
-            format!("{} (Timestamp: {})", datetime, timestamp)
+            format!("{datetime} (Timestamp: {timestamp})")
         }
         _ => "Timestamp does not exist for the index.".to_string(),
     }
@@ -1101,16 +1101,16 @@ pub async fn search_index(args: SearchIndexArgs) -> anyhow::Result<SearchRespons
             serde_json::from_str(&aggs_string).context("failed to deserialize aggregations")
         })
         .transpose()?;
-    let sort_by = args
-        .sort_by_score
-        .then_some(SortBy {
-            sort_fields: vec![SortField {
-                field_name: "_score".to_string(),
-                sort_order: SortOrder::Desc as i32,
-                sort_datetime_format: None,
-            }],
-        })
-        .unwrap_or_default();
+    let sort_fields = if args.sort_by_score {
+        vec![SortField {
+            field_name: "_score".to_string(),
+            sort_order: SortOrder::Desc as i32,
+            sort_datetime_format: None,
+        }]
+    } else {
+        Vec::new()
+    };
+    let sort_by = SortBy { sort_fields };
     let search_request = SearchRequestQueryString {
         query: args.query,
         aggs,

quickwit/quickwit-cli/src/logger.rs

@@ -272,7 +272,7 @@ pub(super) mod jemalloc_profiled {
                     let ext = span.extensions();
                     if let Some(fields) = &ext.get::<FormattedFields<N>>() {
                         if !fields.is_empty() {
-                            write!(writer, "{{{}}}:", fields)?;
+                            write!(writer, "{{{fields}}}:")?;
                         }
                     }
                 }
@@ -289,7 +289,7 @@ pub(super) mod jemalloc_profiled {
             backtrace::trace(|frame| {
                 backtrace::resolve_frame(frame, |symbol| {
                     if let Some(symbole_name) = symbol.name() {
-                        let _ = writeln!(writer, "{}", symbole_name);
+                        let _ = writeln!(writer, "{symbole_name}");
                     } else {
                         let _ = writeln!(writer, "symb failed");
                     }

quickwit/quickwit-cli/src/tool.rs

@@ -560,7 +560,7 @@ pub async fn local_search_cli(args: LocalSearchArgs) -> anyhow::Result<()> {
         single_node_search(search_request, metastore, storage_resolver).await?;
     let search_response_rest = SearchResponseRest::try_from(search_response)?;
     let search_response_json = serde_json::to_string_pretty(&search_response_rest)?;
-    println!("{}", search_response_json);
+    println!("{search_response_json}");
     Ok(())
 }
 

quickwit/quickwit-cli/tests/helpers.rs

@@ -288,7 +288,7 @@ pub async fn upload_test_file(
     filename: &str,
 ) -> Uri {
     let test_data = tokio::fs::read(local_src_path).await.unwrap();
-    let src_location = format!("s3://{}/{}", bucket, prefix);
+    let src_location = format!("s3://{bucket}/{prefix}");
     let storage_uri = Uri::from_str(&src_location).unwrap();
     let storage = storage_resolver.resolve(&storage_uri).await.unwrap();
     storage

quickwit/quickwit-cluster/src/change.rs

@@ -634,7 +634,7 @@ pub(crate) mod tests {
             .await
             .unwrap();
             let ClusterChange::Add(node) = event else {
-                panic!("expected `ClusterChange::Add` event, got `{:?}`", event);
+                panic!("expected `ClusterChange::Add` event, got `{event:?}`");
             };
             assert_eq!(node.chitchat_id(), &updated_chitchat_id);
             assert_eq!(node.grpc_advertise_addr(), grpc_advertise_addr);
@@ -682,7 +682,7 @@ pub(crate) mod tests {
             .unwrap();
 
             let ClusterChange::Update(node) = event else {
-                panic!("expected `ClusterChange::Remove` event, got `{:?}`", event);
+                panic!("expected `ClusterChange::Remove` event, got `{event:?}`");
             };
             assert_eq!(node.chitchat_id(), &updated_chitchat_id);
             assert_eq!(node.grpc_advertise_addr(), grpc_advertise_addr);
@@ -729,7 +729,7 @@ pub(crate) mod tests {
             .await
             .unwrap();
             let ClusterChange::Remove(node) = event else {
-                panic!("expected `ClusterChange::Remove` event, got `{:?}`", event);
+                panic!("expected `ClusterChange::Remove` event, got `{event:?}`");
             };
             assert_eq!(node.chitchat_id(), &updated_chitchat_id);
             assert_eq!(node.grpc_advertise_addr(), grpc_advertise_addr);
@@ -849,7 +849,7 @@ pub(crate) mod tests {
                     .unwrap();
 
             let ClusterChange::Remove(node) = event else {
-                panic!("expected `ClusterChange::Remove` event, got `{:?}`", event);
+                panic!("expected `ClusterChange::Remove` event, got `{event:?}`");
             };
             assert_eq!(node.chitchat_id(), &removed_chitchat_id);
             assert_eq!(node.grpc_advertise_addr(), grpc_advertise_addr);

quickwit/quickwit-cluster/src/cluster.rs

@@ -733,7 +733,7 @@ pub async fn create_cluster_for_test(
 
     static GOSSIP_ADVERTISE_PORT_SEQUENCE: AtomicU16 = AtomicU16::new(1u16);
     let gossip_advertise_port = GOSSIP_ADVERTISE_PORT_SEQUENCE.fetch_add(1, Ordering::Relaxed);
-    let node_id: NodeId = format!("node-{}", gossip_advertise_port).into();
+    let node_id: NodeId = format!("node-{gossip_advertise_port}").into();
 
     let enabled_services = enabled_services
         .iter()

quickwit/quickwit-codegen/src/codegen.rs

@@ -513,8 +513,8 @@ fn generate_client(context: &CodegenContext) -> TokenStream {
     let mock_name = &context.mock_name;
     let mock_wrapper_name = quote::format_ident!("{}Wrapper", mock_name);
     let error_message = format!(
-        "`{}` must be wrapped in a `{}`: use `{}::from_mock(mock)` to instantiate the client",
-        mock_name, mock_wrapper_name, client_name
+        "`{mock_name}` must be wrapped in a `{mock_wrapper_name}`: use \
+         `{client_name}::from_mock(mock)` to instantiate the client"
     );
     let extra_client_methods = if context.generate_extra_service_methods {
         generate_extra_methods_calling_inner()

quickwit/quickwit-common/src/pretty.rs

@@ -63,7 +63,7 @@ impl fmt::Display for PrettyDurationDisplay<'_> {
         let duration_millis = self.0.as_millis();
 
         if duration_millis < 1_000 {
-            return write!(formatter, "{}ms", duration_millis);
+            return write!(formatter, "{duration_millis}ms");
         }
         write!(
             formatter,

quickwit/quickwit-common/src/temp_dir.rs

@@ -319,7 +319,7 @@ mod tests {
             builder.join(part);
         }
         let prefix = builder.prefix().unwrap();
-        assert_eq!(expected_path, prefix, "parts: {:?} len: {:?}", parts, size);
+        assert_eq!(expected_path, prefix, "parts: {parts:?} len: {size:?}");
     }
 
     fn assert_prefix_err(expected_err: &str, parts: Vec<&str>, size: usize) {
@@ -369,14 +369,12 @@ mod tests {
             } else {
                 let len = limit_threshold + rand::random::<usize>() % 100;
                 builder.max_length(len);
-                let builder_debug = format!("{:?}, len {}", builder, len);
+                let builder_debug = format!("{builder:?}, len {len}");
                 let builder_prefix = builder.prefix().unwrap();
                 assert_eq!(
                     builder_prefix.len(),
                     cmp::min(len - rand_bytes, max_size),
-                    "{} -> {}",
-                    builder_debug,
-                    builder_prefix
+                    "{builder_debug} -> {builder_prefix}"
                 );
             }
         }

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

@@ -104,8 +104,8 @@ where
         self.pool
             .read()
             .expect("lock should not be poisoned")
-            .iter()
-            .map(|(key, _)| key.clone())
+            .keys()
+            .cloned()
             .collect()
     }
 
@@ -114,8 +114,8 @@ where
         self.pool
             .read()
             .expect("lock should not be poisoned")
-            .iter()
-            .map(|(_, value)| value.clone())
+            .values()
+            .cloned()
             .collect()
     }