Fix clippy::uninlined_format_args lint

argerus · SebastianSchildt · commit db8a5af3216e · 2023-02-13T11:01:34.000+01:00
https://rust-lang.github.io/rust-clippy/master/#uninlined_format_args This lint was promoted from "pedantic" in Rust 1.67.0. It was subsequently [demoted to "pedantic" again](rust-lang/rust#107743) in 1.67.1, so one solution would be to just use another version for now. It does however seem likely that it will be reintroduced at some point, so applying the fix. rust-lang/rust-clippy#10265
diff --git a/databroker-cli/src/main.rs b/databroker-cli/src/main.rs
@@ -94,7 +94,7 @@ async fn connect(
         }
         Err(err) => {
             set_disconnected_prompt(interface);
-            writeln!(interface, "{}", err).unwrap();
+            writeln!(interface, "{err}").unwrap();
             None
         }
     }
@@ -132,7 +132,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let addr = std::env::var("KUKSA_DATA_BROKER_ADDR").unwrap_or_else(|_| "127.0.0.1".to_owned());
     let port = std::env::var("KUKSA_DATA_BROKER_PORT").unwrap_or_else(|_| "55555".to_owned());
-    let mut uri = match addr_to_uri(format!("{}:{}", addr, port)) {
+    let mut uri = match addr_to_uri(format!("{addr}:{port}")) {
         Some(uri) => uri,
         None => return Err(Box::new(ParseError {}).into()),
     };
@@ -154,10 +154,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     let (cmd, args) = split_first_word(&line);
                     match cmd {
                         "help" => {
-                            println!("{} commands:", APP_NAME);
+                            println!("{APP_NAME} commands:");
                             println!();
                             for &(cmd, help) in CLI_COMMANDS {
-                                println!("  {:15} - {}", cmd, help);
+                                println!("  {cmd:15} - {help}");
                             }
                             println!();
                         }
@@ -270,15 +270,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                         ) {
                                                             Some(error) => {
                                                                 println!(
-                                                                    "-> Error setting id {}: {:?}",
-                                                                    id, error
+                                                                    "-> Error setting id {id}: {error:?}"
                                                                 )
                                                             }
                                                             None => {
-                                                                println!(
-                                                                    "-> Error setting id {}",
-                                                                    id
-                                                                )
+                                                                println!("-> Error setting id {id}")
                                                             }
                                                         }
                                                     }
@@ -367,15 +363,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                         ) {
                                                             Some(error) => {
                                                                 println!(
-                                                                    "-> Error setting id {}: {:?}",
-                                                                    id, error
+                                                                    "-> Error setting id {id}: {error:?}"
                                                                 )
                                                             }
                                                             None => {
-                                                                println!(
-                                                                    "-> Error setting id {}",
-                                                                    id
-                                                                )
+                                                                println!("-> Error setting id {id}")
                                                             }
                                                         }
                                                     }
@@ -417,8 +409,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         tonic::Request::new(proto::v1::SubscribeRequest { query });
                                     match client.subscribe(args).await {
                                         Ok(response) => {
-                                            let sub_id =
-                                                format!("subscription{}", subscription_nbr);
+                                            let sub_id = format!("subscription{subscription_nbr}");
                                             subscription_nbr += 1;
                                             tokio::spawn(async move {
                                                 let mut stream = response.into_inner();
@@ -441,8 +432,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                                 }
                                                                 writeln!(
                                                                     iface,
-                                                                    "-> {}:\n{}",
-                                                                    sub_id, output
+                                                                    "-> {sub_id}:\n{output}"
                                                                 )
                                                                 .unwrap();
                                                             }
@@ -531,7 +521,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     break;
                 }
                 ReadResult::Signal(sig) => {
-                    println!("received signal: {:?}", sig);
+                    println!("received signal: {sig:?}");
                 }
             }
         }
@@ -778,9 +768,9 @@ where
     let real_delimiter = ", ";
     let mut delimiter = "";
     for value in array {
-        write!(f, "{}", delimiter)?;
+        write!(f, "{delimiter}")?;
         delimiter = real_delimiter;
-        write!(f, "{}", value)?;
+        write!(f, "{value}")?;
     }
     f.write_str("]")
 }
@@ -790,32 +780,32 @@ impl fmt::Display for DisplayDatapoint {
         match &self.0.value {
             Some(value) => match value {
                 proto::v1::datapoint::Value::BoolValue(value) => {
-                    f.write_fmt(format_args!("{}", value))
+                    f.write_fmt(format_args!("{value}"))
                 }
                 proto::v1::datapoint::Value::FailureValue(failure) => f.write_fmt(format_args!(
                     "( {:?} )",
                     proto::v1::datapoint::Failure::from_i32(*failure).unwrap()
                 )),
                 proto::v1::datapoint::Value::Int32Value(value) => {
-                    f.write_fmt(format_args!("{}", value))
+                    f.write_fmt(format_args!("{value}"))
                 }
                 proto::v1::datapoint::Value::Int64Value(value) => {
-                    f.write_fmt(format_args!("{}", value))
+                    f.write_fmt(format_args!("{value}"))
                 }
                 proto::v1::datapoint::Value::Uint32Value(value) => {
-                    f.write_fmt(format_args!("{}", value))
+                    f.write_fmt(format_args!("{value}"))
                 }
                 proto::v1::datapoint::Value::Uint64Value(value) => {
-                    f.write_fmt(format_args!("{}", value))
+                    f.write_fmt(format_args!("{value}"))
                 }
                 proto::v1::datapoint::Value::FloatValue(value) => {
-                    f.write_fmt(format_args!("{:.2}", value))
+                    f.write_fmt(format_args!("{value:.2}"))
                 }
                 proto::v1::datapoint::Value::DoubleValue(value) => {
-                    f.write_fmt(format_args!("{}", value))
+                    f.write_fmt(format_args!("{value}"))
                 }
                 proto::v1::datapoint::Value::StringValue(value) => {
-                    f.write_fmt(format_args!("'{}'", value))
+                    f.write_fmt(format_args!("'{value}'"))
                 }
                 proto::v1::datapoint::Value::StringArray(array) => display_array(f, &array.values),
                 proto::v1::datapoint::Value::BoolArray(array) => display_array(f, &array.values),
diff --git a/databroker-examples/examples/perf_setter.rs b/databroker-examples/examples/perf_setter.rs
@@ -59,7 +59,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {
             {
                 Ok(metadata) => metadata.into_inner().results["Vehicle.ADAS.ABS.Error"],
                 Err(err) => {
-                    println!("Couldn't retrieve metadata: {:?}", err);
+                    println!("Couldn't retrieve metadata: {err:?}");
                     -1
                 }
             };
@@ -108,7 +108,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {
                     Ok(_) => {
                         eprintln!("START");
                     }
-                    Err(err) => eprint!("{}", err),
+                    Err(err) => eprint!("{err}"),
                 };
 
                 let mut n: i32 = 0;
@@ -135,7 +135,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {
                             }
                             n += 1;
                         }
-                        Err(err) => eprint!("{}", err),
+                        Err(err) => eprint!("{err}"),
                     };
                 }
 
@@ -144,7 +144,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {
                     Ok(_) => {
                         eprintln!("\rEND                                                    ");
                     }
-                    Err(err) => eprint!("{}", err),
+                    Err(err) => eprint!("{err}"),
                 };
 
                 (n, n_id)
@@ -153,7 +153,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {
             let (n, n_id) = feeder.await.unwrap();
             match sender.await {
                 Ok(_) => {}
-                Err(err) => eprint!("{}", err),
+                Err(err) => eprint!("{err}"),
             };
 
             let seconds = now.elapsed().as_secs_f64();
@@ -167,10 +167,10 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {
                 n_id,
                 n_id as f64 / seconds
             );
-            println!("Completed in {:.3} s", seconds);
+            println!("Completed in {seconds:.3} s");
         }
         Err(err) => {
-            println!("{}", err);
+            println!("{err}");
         }
     }
 }
@@ -194,7 +194,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         None => DEFAULT_NTH_MESSAGE,
     };
 
-    println!("INPUT: Set {} times", iterations);
+    println!("INPUT: Set {iterations} times");
 
     // run_set_test(iterations).await;
     run_streaming_set_test(iterations, queue_size).await;
diff --git a/databroker-examples/examples/perf_subscriber.rs b/databroker-examples/examples/perf_subscriber.rs
@@ -45,7 +45,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     match value {
                                         proto::v1::datapoint::Value::FailureValue(reason) => {
                                             if started {
-                                                eprintln!("-> Failure: {:?}", reason);
+                                                eprintln!("-> Failure: {reason:?}");
                                             }
                                         }
                                         proto::v1::datapoint::Value::StringValue(string_value) => {
@@ -66,7 +66,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                             n,
                                                             n as f64 / seconds
                                                         );
-                                                        eprintln!("Completed in {:.3} s", seconds);
+                                                        eprintln!("Completed in {seconds:.3} s");
                                                     }
                                                 }
                                                 _ => {
@@ -105,7 +105,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
         }
         Err(err) => {
-            eprintln!("{}", err);
+            eprintln!("{err}");
         }
     }
 
diff --git a/databroker/build.rs b/databroker/build.rs
@@ -36,7 +36,7 @@ fn main() -> Result<()> {
         Ok(ok) => Ok(ok),
         Err(e) => {
             // Swallow the errors for now (enable with -vv)
-            eprintln!("vergen failed: {}", e);
+            eprintln!("vergen failed: {e}");
             Ok(())
         }
     }
diff --git a/databroker/src/broker.rs b/databroker/src/broker.rs
@@ -961,7 +961,7 @@ impl DataBroker {
                 let stream = ReceiverStream::new(receiver);
                 Ok(stream)
             }
-            Err(e) => Err(QueryError::CompilationError(format!("{:?}", e))),
+            Err(e) => Err(QueryError::CompilationError(format!("{e:?}"))),
         }
     }
 
diff --git a/databroker/src/grpc/kuksa_val_v1/val.rs b/databroker/src/grpc/kuksa_val_v1/val.rs
@@ -196,8 +196,7 @@ impl proto::val_server::Val for broker::DataBroker {
                     },
                     None => {
                         return Err(tonic::Status::invalid_argument(format!(
-                            "Invalid Field (id: {})",
-                            id
+                            "Invalid Field (id: {id})"
                         )))
                     }
                 };
@@ -212,7 +211,7 @@ impl proto::val_server::Val for broker::DataBroker {
             }
             Err(e) => Err(tonic::Status::new(
                 tonic::Code::InvalidArgument,
-                format!("{:?}", e),
+                format!("{e:?}"),
             )),
         }
     }
diff --git a/databroker/src/grpc/sdv_databroker_v1/broker.rs b/databroker/src/grpc/sdv_databroker_v1/broker.rs
@@ -146,7 +146,7 @@ impl proto::broker_server::Broker for broker::DataBroker {
                 debug!("Subscribed to new query");
                 Ok(Response::new(Box::pin(stream)))
             }
-            Err(e) => Err(Status::new(Code::InvalidArgument, format!("{:?}", e))),
+            Err(e) => Err(Status::new(Code::InvalidArgument, format!("{e:?}"))),
         }
     }
 
diff --git a/databroker/src/main.rs b/databroker/src/main.rs
@@ -110,7 +110,7 @@ const DATAPOINTS: &[(
 fn init_logging() {
     let mut output = String::from("Init logging from RUST_LOG");
     let filter = EnvFilter::try_from_default_env().unwrap_or_else(|err| {
-        output.write_fmt(format_args!(" ({})", err)).unwrap();
+        output.write_fmt(format_args!(" ({err})")).unwrap();
         // If no environment variable set, this is the default
         EnvFilter::new("info")
     });
@@ -306,7 +306,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                         .await
                     {
                         Ok(_) => {}
-                        Err(e) => println!("{:?}", e),
+                        Err(e) => println!("{e:?}"),
                     }
                 }
             }
diff --git a/databroker/src/query/compiler.rs b/databroker/src/query/compiler.rs
@@ -163,17 +163,15 @@ pub fn compile_expr(
                         Ok(left_expr) => (Box::new(left_expr), Box::new(right_expr)),
                         Err(_) => {
                             return Err(CompilationError::TypeError(format!(
-                                "left side is incompatible with right side in expression \"{}\"",
-                                expr
+                                "left side is incompatible with right side in expression \"{expr}\""
                             )))
                         }
                     },
                     (Ok(left_type), Err(literal)) => match resolve_literal(literal, left_type) {
                         Ok(right_expr) => (Box::new(left_expr), Box::new(right_expr)),
                         Err(_) => {
                             return Err(CompilationError::TypeError(format!(
-                                "right side is incompatible with left side in expression \"{}\"",
-                                expr
+                                "right side is incompatible with left side in expression \"{expr}\""
                             )))
                         }
                     },
@@ -222,8 +220,7 @@ pub fn compile_expr(
                                                     }),
                                                 ),
                                                 _ => return Err(CompilationError::TypeError(format!(
-                                                    "right side is incompatible with left side in expression \"{}\"",
-                                                    expr
+                                                    "right side is incompatible with left side in expression \"{expr}\""
                                                 )))
                                             },
                                         }
@@ -232,8 +229,7 @@ pub fn compile_expr(
                             }
                             _ => {
                                 return Err(CompilationError::TypeError(format!(
-                                "right side is incompatible with left side in expression \"{}\"",
-                                expr
+                                "right side is incompatible with left side in expression \"{expr}\""
                             )))
                             }
                         }
@@ -295,10 +291,9 @@ pub fn compile_expr(
                         "OR requires boolean expressions on both sides".to_string(),
                     )),
                 },
-                operator => Err(CompilationError::UnsupportedOperator(format!(
-                    "{}",
-                    operator,
-                ))),
+                operator => Err(CompilationError::UnsupportedOperator(
+                    format!("{operator}",),
+                )),
             }
         }
         ast::Expr::Nested(e) => compile_expr(e, input, output),
@@ -309,8 +304,7 @@ pub fn compile_expr(
                 operator: UnaryOperator::Not,
             }),
             operator => Err(CompilationError::UnsupportedOperator(format!(
-                "Unsupported unary operator \"{}\"",
-                operator
+                "Unsupported unary operator \"{operator}\""
             ))),
         },
 
@@ -326,8 +320,7 @@ pub fn compile_expr(
             high: Box::new(compile_expr(high, input, output)?),
         }),
         operator => Err(CompilationError::UnsupportedOperator(format!(
-            "Unsupported operator \"{}\"",
-            operator
+            "Unsupported operator \"{operator}\""
         ))),
     }
 }
@@ -476,6 +469,6 @@ pub fn compile(
                 ))
             }
         }
-        Err(e) => Err(CompilationError::ParseError(format!("{}", e))),
+        Err(e) => Err(CompilationError::ParseError(format!("{e}"))),
     }
 }
diff --git a/databroker/src/query/executor.rs b/databroker/src/query/executor.rs
diff --git a/databroker/src/vss.rs b/databroker/src/vss.rs

Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ async fn connect(`
`94`	`94`	`}`
`95`	`95`	`Err(err) => {`
`96`	`96`	`set_disconnected_prompt(interface);`
`97`		`- writeln!(interface, "{}", err).unwrap();`
	`97`	`+ writeln!(interface, "{err}").unwrap();`
`98`	`98`	`None`
`99`	`99`	`}`
`100`	`100`	`}`
`@@ -132,7 +132,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`132`	`132`
`133`	`133`	`let addr = std::env::var("KUKSA_DATA_BROKER_ADDR").unwrap_or_else(\|_\| "127.0.0.1".to_owned());`
`134`	`134`	`let port = std::env::var("KUKSA_DATA_BROKER_PORT").unwrap_or_else(\|_\| "55555".to_owned());`
`135`		`- let mut uri = match addr_to_uri(format!("{}:{}", addr, port)) {`
	`135`	`+ let mut uri = match addr_to_uri(format!("{addr}:{port}")) {`
`136`	`136`	`Some(uri) => uri,`
`137`	`137`	`None => return Err(Box::new(ParseError {}).into()),`
`138`	`138`	`};`
`@@ -154,10 +154,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`154`	`154`	`let (cmd, args) = split_first_word(&line);`
`155`	`155`	`match cmd {`
`156`	`156`	`"help" => {`
`157`		`- println!("{} commands:", APP_NAME);`
	`157`	`+ println!("{APP_NAME} commands:");`
`158`	`158`	`println!();`
`159`	`159`	`for &(cmd, help) in CLI_COMMANDS {`
`160`		`- println!(" {:15} - {}", cmd, help);`
	`160`	`+ println!(" {cmd:15} - {help}");`
`161`	`161`	`}`
`162`	`162`	`println!();`
`163`	`163`	`}`
`@@ -270,15 +270,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`270`	`270`	`) {`
`271`	`271`	`Some(error) => {`
`272`	`272`	`println!(`
`273`		`- "-> Error setting id {}: {:?}",`
`274`		`- id, error`
	`273`	`+ "-> Error setting id {id}: {error:?}"`
`275`	`274`	`)`
`276`	`275`	`}`
`277`	`276`	`None => {`
`278`		`- println!(`
`279`		`- "-> Error setting id {}",`
`280`		`- id`
`281`		`- )`
	`277`	`+ println!("-> Error setting id {id}")`
`282`	`278`	`}`
`283`	`279`	`}`
`284`	`280`	`}`
`@@ -367,15 +363,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`367`	`363`	`) {`
`368`	`364`	`Some(error) => {`
`369`	`365`	`println!(`
`370`		`- "-> Error setting id {}: {:?}",`
`371`		`- id, error`
	`366`	`+ "-> Error setting id {id}: {error:?}"`
`372`	`367`	`)`
`373`	`368`	`}`
`374`	`369`	`None => {`
`375`		`- println!(`
`376`		`- "-> Error setting id {}",`
`377`		`- id`
`378`		`- )`
	`370`	`+ println!("-> Error setting id {id}")`
`379`	`371`	`}`
`380`	`372`	`}`
`381`	`373`	`}`
`@@ -417,8 +409,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`417`	`409`	`tonic::Request::new(proto::v1::SubscribeRequest { query });`
`418`	`410`	`match client.subscribe(args).await {`
`419`	`411`	`Ok(response) => {`
`420`		`- let sub_id =`
`421`		`- format!("subscription{}", subscription_nbr);`
	`412`	`+ let sub_id = format!("subscription{subscription_nbr}");`
`422`	`413`	`subscription_nbr += 1;`
`423`	`414`	`tokio::spawn(async move {`
`424`	`415`	`let mut stream = response.into_inner();`
`@@ -441,8 +432,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`441`	`432`	`}`
`442`	`433`	`writeln!(`
`443`	`434`	`iface,`
`444`		`- "-> {}:\n{}",`
`445`		`- sub_id, output`
	`435`	`+ "-> {sub_id}:\n{output}"`
`446`	`436`	`)`
`447`	`437`	`.unwrap();`
`448`	`438`	`}`
`@@ -531,7 +521,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`531`	`521`	`break;`
`532`	`522`	`}`
`533`	`523`	`ReadResult::Signal(sig) => {`
`534`		`- println!("received signal: {:?}", sig);`
	`524`	`+ println!("received signal: {sig:?}");`
`535`	`525`	`}`
`536`	`526`	`}`
`537`	`527`	`}`
`@@ -778,9 +768,9 @@ where`
`778`	`768`	`let real_delimiter = ", ";`
`779`	`769`	`let mut delimiter = "";`
`780`	`770`	`for value in array {`
`781`		`- write!(f, "{}", delimiter)?;`
	`771`	`+ write!(f, "{delimiter}")?;`
`782`	`772`	`delimiter = real_delimiter;`
`783`		`- write!(f, "{}", value)?;`
	`773`	`+ write!(f, "{value}")?;`
`784`	`774`	`}`
`785`	`775`	`f.write_str("]")`
`786`	`776`	`}`
`@@ -790,32 +780,32 @@ impl fmt::Display for DisplayDatapoint {`
`790`	`780`	`match &self.0.value {`
`791`	`781`	`Some(value) => match value {`
`792`	`782`	`proto::v1::datapoint::Value::BoolValue(value) => {`
`793`		`- f.write_fmt(format_args!("{}", value))`
	`783`	`+ f.write_fmt(format_args!("{value}"))`
`794`	`784`	`}`
`795`	`785`	`proto::v1::datapoint::Value::FailureValue(failure) => f.write_fmt(format_args!(`
`796`	`786`	`"( {:?} )",`
`797`	`787`	`proto::v1::datapoint::Failure::from_i32(*failure).unwrap()`
`798`	`788`	`)),`
`799`	`789`	`proto::v1::datapoint::Value::Int32Value(value) => {`
`800`		`- f.write_fmt(format_args!("{}", value))`
	`790`	`+ f.write_fmt(format_args!("{value}"))`
`801`	`791`	`}`
`802`	`792`	`proto::v1::datapoint::Value::Int64Value(value) => {`
`803`		`- f.write_fmt(format_args!("{}", value))`
	`793`	`+ f.write_fmt(format_args!("{value}"))`
`804`	`794`	`}`
`805`	`795`	`proto::v1::datapoint::Value::Uint32Value(value) => {`
`806`		`- f.write_fmt(format_args!("{}", value))`
	`796`	`+ f.write_fmt(format_args!("{value}"))`
`807`	`797`	`}`
`808`	`798`	`proto::v1::datapoint::Value::Uint64Value(value) => {`
`809`		`- f.write_fmt(format_args!("{}", value))`
	`799`	`+ f.write_fmt(format_args!("{value}"))`
`810`	`800`	`}`
`811`	`801`	`proto::v1::datapoint::Value::FloatValue(value) => {`
`812`		`- f.write_fmt(format_args!("{:.2}", value))`
	`802`	`+ f.write_fmt(format_args!("{value:.2}"))`
`813`	`803`	`}`
`814`	`804`	`proto::v1::datapoint::Value::DoubleValue(value) => {`
`815`		`- f.write_fmt(format_args!("{}", value))`
	`805`	`+ f.write_fmt(format_args!("{value}"))`
`816`	`806`	`}`
`817`	`807`	`proto::v1::datapoint::Value::StringValue(value) => {`
`818`		`- f.write_fmt(format_args!("'{}'", value))`
	`808`	`+ f.write_fmt(format_args!("'{value}'"))`
`819`	`809`	`}`
`820`	`810`	`proto::v1::datapoint::Value::StringArray(array) => display_array(f, &array.values),`
`821`	`811`	`proto::v1::datapoint::Value::BoolArray(array) => display_array(f, &array.values),`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {`
`59`	`59`	`{`
`60`	`60`	`Ok(metadata) => metadata.into_inner().results["Vehicle.ADAS.ABS.Error"],`
`61`	`61`	`Err(err) => {`
`62`		`- println!("Couldn't retrieve metadata: {:?}", err);`
	`62`	`+ println!("Couldn't retrieve metadata: {err:?}");`
`63`	`63`	`-1`
`64`	`64`	`}`
`65`	`65`	`};`
`@@ -108,7 +108,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {`
`108`	`108`	`Ok(_) => {`
`109`	`109`	`eprintln!("START");`
`110`	`110`	`}`
`111`		`- Err(err) => eprint!("{}", err),`
	`111`	`+ Err(err) => eprint!("{err}"),`
`112`	`112`	`};`
`113`	`113`
`114`	`114`	`let mut n: i32 = 0;`
`@@ -135,7 +135,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {`
`135`	`135`	`}`
`136`	`136`	`n += 1;`
`137`	`137`	`}`
`138`		`- Err(err) => eprint!("{}", err),`
	`138`	`+ Err(err) => eprint!("{err}"),`
`139`	`139`	`};`
`140`	`140`	`}`
`141`	`141`
`@@ -144,7 +144,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {`
`144`	`144`	`Ok(_) => {`
`145`	`145`	`eprintln!("\rEND ");`
`146`	`146`	`}`
`147`		`- Err(err) => eprint!("{}", err),`
	`147`	`+ Err(err) => eprint!("{err}"),`
`148`	`148`	`};`
`149`	`149`
`150`	`150`	`(n, n_id)`
`@@ -153,7 +153,7 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {`
`153`	`153`	`let (n, n_id) = feeder.await.unwrap();`
`154`	`154`	`match sender.await {`
`155`	`155`	`Ok(_) => {}`
`156`		`- Err(err) => eprint!("{}", err),`
	`156`	`+ Err(err) => eprint!("{err}"),`
`157`	`157`	`};`
`158`	`158`
`159`	`159`	`let seconds = now.elapsed().as_secs_f64();`
`@@ -167,10 +167,10 @@ async fn run_streaming_set_test(iterations: i32, n_th_message: i32) {`
`167`	`167`	`n_id,`
`168`	`168`	`n_id as f64 / seconds`
`169`	`169`	`);`
`170`		`- println!("Completed in {:.3} s", seconds);`
	`170`	`+ println!("Completed in {seconds:.3} s");`
`171`	`171`	`}`
`172`	`172`	`Err(err) => {`
`173`		`- println!("{}", err);`
	`173`	`+ println!("{err}");`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`	`}`
`@@ -194,7 +194,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`194`	`194`	`None => DEFAULT_NTH_MESSAGE,`
`195`	`195`	`};`
`196`	`196`
`197`		`- println!("INPUT: Set {} times", iterations);`
	`197`	`+ println!("INPUT: Set {iterations} times");`
`198`	`198`
`199`	`199`	`// run_set_test(iterations).await;`
`200`	`200`	`run_streaming_set_test(iterations, queue_size).await;`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`45`	`45`	`match value {`
`46`	`46`	`proto::v1::datapoint::Value::FailureValue(reason) => {`
`47`	`47`	`if started {`
`48`		`- eprintln!("-> Failure: {:?}", reason);`
	`48`	`+ eprintln!("-> Failure: {reason:?}");`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`proto::v1::datapoint::Value::StringValue(string_value) => {`
`@@ -66,7 +66,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`66`	`66`	`n,`
`67`	`67`	`n as f64 / seconds`
`68`	`68`	`);`
`69`		`- eprintln!("Completed in {:.3} s", seconds);`
	`69`	`+ eprintln!("Completed in {seconds:.3} s");`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`_ => {`
`@@ -105,7 +105,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`	`Err(err) => {`
`108`		`- eprintln!("{}", err);`
	`108`	`+ eprintln!("{err}");`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ fn main() -> Result<()> {`
`36`	`36`	`Ok(ok) => Ok(ok),`
`37`	`37`	`Err(e) => {`
`38`	`38`	`// Swallow the errors for now (enable with -vv)`
`39`		`- eprintln!("vergen failed: {}", e);`
	`39`	`+ eprintln!("vergen failed: {e}");`
`40`	`40`	`Ok(())`
`41`	`41`	`}`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -961,7 +961,7 @@ impl DataBroker {`
`961`	`961`	`let stream = ReceiverStream::new(receiver);`
`962`	`962`	`Ok(stream)`
`963`	`963`	`}`
`964`		`- Err(e) => Err(QueryError::CompilationError(format!("{:?}", e))),`
	`964`	`+ Err(e) => Err(QueryError::CompilationError(format!("{e:?}"))),`
`965`	`965`	`}`
`966`	`966`	`}`
`967`	`967`
Original file line number	Diff line number	Diff line change
`@@ -196,8 +196,7 @@ impl proto::val_server::Val for broker::DataBroker {`
`196`	`196`	`},`
`197`	`197`	`None => {`
`198`	`198`	`return Err(tonic::Status::invalid_argument(format!(`
`199`		`- "Invalid Field (id: {})",`
`200`		`- id`
	`199`	`+ "Invalid Field (id: {id})"`
`201`	`200`	`)))`
`202`	`201`	`}`
`203`	`202`	`};`
`@@ -212,7 +211,7 @@ impl proto::val_server::Val for broker::DataBroker {`
`212`	`211`	`}`
`213`	`212`	`Err(e) => Err(tonic::Status::new(`
`214`	`213`	`tonic::Code::InvalidArgument,`
`215`		`- format!("{:?}", e),`
	`214`	`+ format!("{e:?}"),`
`216`	`215`	`)),`
`217`	`216`	`}`
`218`	`217`	`}`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ impl proto::broker_server::Broker for broker::DataBroker {`
`146`	`146`	`debug!("Subscribed to new query");`
`147`	`147`	`Ok(Response::new(Box::pin(stream)))`
`148`	`148`	`}`
`149`		`- Err(e) => Err(Status::new(Code::InvalidArgument, format!("{:?}", e))),`
	`149`	`+ Err(e) => Err(Status::new(Code::InvalidArgument, format!("{e:?}"))),`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ const DATAPOINTS: &[(`
`110`	`110`	`fn init_logging() {`
`111`	`111`	`let mut output = String::from("Init logging from RUST_LOG");`
`112`	`112`	`let filter = EnvFilter::try_from_default_env().unwrap_or_else(\|err\| {`
`113`		`- output.write_fmt(format_args!(" ({})", err)).unwrap();`
	`113`	`+ output.write_fmt(format_args!(" ({err})")).unwrap();`
`114`	`114`	`// If no environment variable set, this is the default`
`115`	`115`	`EnvFilter::new("info")`
`116`	`116`	`});`
`@@ -306,7 +306,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`306`	`306`	`.await`
`307`	`307`	`{`
`308`	`308`	`Ok(_) => {}`
`309`		`- Err(e) => println!("{:?}", e),`
	`309`	`+ Err(e) => println!("{e:?}"),`
`310`	`310`	`}`
`311`	`311`	`}`
`312`	`312`	`}`