Rust: 'fix' clippys for Rust 1.67

This is clippy getting a bit above itself IMHO

Signed-off-by: Christine Caulfield <ccaulfie@redhat.com>
Reviewed-by: Jan Friesse <jfriesse@redhat.com>

bindings/rust/src/cmap.rs

@@ -244,18 +244,18 @@ impl fmt::Display for DataType {
 impl fmt::Display for Data {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Data::Int8(v) => write!(f, "{} (Int8)", v),
-            Data::UInt8(v) => write!(f, "{} (UInt8)", v),
-            Data::Int16(v) => write!(f, "{} (Int16)", v),
-            Data::UInt16(v) => write!(f, "{} (UInt16)", v),
-            Data::Int32(v) => write!(f, "{} (Int32)", v),
-            Data::UInt32(v) => write!(f, "{} (UInt32)", v),
-            Data::Int64(v) => write!(f, "{} (Int64)", v),
-            Data::UInt64(v) => write!(f, "{} (UInt64)", v),
-            Data::Float(v) => write!(f, "{} (Float)", v),
-            Data::Double(v) => write!(f, "{} (Double)", v),
-            Data::String(v) => write!(f, "{} (String)", v),
-            Data::Binary(v) => write!(f, "{:?} (Binary)", v),
+            Data::Int8(v) => write!(f, "{v} (Int8)"),
+            Data::UInt8(v) => write!(f, "{v} (UInt8)"),
+            Data::Int16(v) => write!(f, "{v} (Int16)"),
+            Data::UInt16(v) => write!(f, "{v} (UInt16)"),
+            Data::Int32(v) => write!(f, "{v} (Int32)"),
+            Data::UInt32(v) => write!(f, "{v} (UInt32)"),
+            Data::Int64(v) => write!(f, "{v} (Int64)"),
+            Data::UInt64(v) => write!(f, "{v} (UInt64)"),
+            Data::Float(v) => write!(f, "{v} (Float)"),
+            Data::Double(v) => write!(f, "{v} (Double)"),
+            Data::String(v) => write!(f, "{v} (String)"),
+            Data::Binary(v) => write!(f, "{v:?} (Binary)"),
             Data::Unknown => write!(f, "Unknown)"),
         }
     }

bindings/rust/tests/src/bin/cfg-test.rs

@@ -19,7 +19,7 @@ fn shutdown_check_fn(handle: &cfg::Handle, _flags: u32) {
 
     // DON'T shutdown corosync - we're just testing
     if let Err(e) = cfg::reply_to_shutdown(*handle, cfg::ShutdownReply::No) {
-        println!("Error in CFG replyto_shutdown: {}", e);
+        println!("Error in CFG replyto_shutdown: {e}");
     }
 }
 
@@ -35,7 +35,7 @@ fn main() {
             h
         }
         Err(e) => {
-            println!("Error in CFG init: {}", e);
+            println!("Error in CFG init: {e}");
             return;
         }
     };
@@ -47,7 +47,7 @@ fn main() {
             h
         }
         Err(e) => {
-            println!("Error in CFG init: {}", e);
+            println!("Error in CFG init: {e}");
             return;
         }
     };
@@ -58,18 +58,18 @@ fn main() {
             spawn(move || dispatch_thread(handle2));
         }
         Err(e) => {
-            println!("Error in CFG track_start: {}", e);
+            println!("Error in CFG track_start: {e}");
         }
     };
 
     let local_nodeid = {
         match cfg::local_get(handle) {
             Ok(n) => {
-                println!("Local nodeid is {}", n);
+                println!("Local nodeid is {n}");
                 Some(n)
             }
             Err(e) => {
-                println!("Error in CFG local_get: {}", e);
+                println!("Error in CFG local_get: {e}");
                 None
             }
         }
@@ -84,7 +84,7 @@ fn main() {
         let us_less1 = NodeId::from(u32::from(our_nodeid) - 1);
         let mut res = cfg::node_status_get(handle, us_plus1, cfg::NodeStatusVersion::V1);
         if let Err(e) = res {
-            println!("Error from node_status_get on nodeid {}: {}", us_plus1, e);
+            println!("Error from node_status_get on nodeid {us_plus1}: {e}");
             res = cfg::node_status_get(handle, us_less1, cfg::NodeStatusVersion::V1);
         };
         match res {
@@ -97,7 +97,7 @@ fn main() {
                 println!("   onwire_ver: {}", ns.onwire_ver);
                 for (ls_num, ls) in ns.link_status.iter().enumerate() {
                     if ls.enabled {
-                        println!("   Link {}", ls_num);
+                        println!("   Link {ls_num}");
                         println!("      connected: {}", ls.connected);
                         println!("      mtu: {}", ls.mtu);
                         println!("      src: {}", ls.src_ipaddr);
@@ -107,8 +107,7 @@ fn main() {
             }
             Err(e) => {
                 println!(
-                    "Error in CFG node_status get: {} (tried nodeids {} & {})",
-                    e, us_plus1, us_less1
+                    "Error in CFG node_status get: {e} (tried nodeids {us_plus1} & {us_less1})"
                 );
             }
         }
@@ -121,7 +120,7 @@ fn main() {
         }
         Err(e) => {
             if e != corosync::CsError::CsErrBusy {
-                println!("Error in CFG try_shutdown: {}", e);
+                println!("Error in CFG try_shutdown: {e}");
             }
         }
     }

bindings/rust/tests/src/bin/cmap-test.rs

@@ -13,12 +13,9 @@ fn track_notify_fn(
     user_data: u64,
 ) {
     println!("Track notify callback");
-    println!(
-        "Key: {}, event: {}, user_data: {}",
-        key_name, event, user_data
-    );
-    println!("   Old value: {}", old_value);
-    println!("   New value: {}", new_value);
+    println!("Key: {key_name}, event: {event}, user_data: {user_data}");
+    println!("   Old value: {old_value}");
+    println!("   New value: {new_value}");
 }
 
 fn main() {
@@ -28,112 +25,112 @@ fn main() {
             h
         }
         Err(e) => {
-            println!("Error in CMAP (Icmap) init: {}", e);
+            println!("Error in CMAP (Icmap) init: {e}");
             return;
         }
     };
 
     // Test some SETs
     if let Err(e) = cmap::set_u32(handle, "test.test_uint32", 456) {
-        println!("Error in CMAP set_u32: {}", e);
+        println!("Error in CMAP set_u32: {e}");
         return;
     };
 
     if let Err(e) = cmap::set_i16(handle, "test.test_int16", -789) {
-        println!("Error in CMAP set_i16: {}", e);
+        println!("Error in CMAP set_i16: {e}");
         return;
     };
 
     if let Err(e) = cmap::set_number(handle, "test.test_num_1", 6809u32) {
-        println!("Error in CMAP set_number(u32): {}", e);
+        println!("Error in CMAP set_number(u32): {e}");
         return;
     };
 
     // NOT PI (just to avoid clippy whingeing)
     if let Err(e) = cmap::set_number(handle, "test.test_num_2", 3.24159265) {
-        println!("Error in CMAP set_number(f32): {}", e);
+        println!("Error in CMAP set_number(f32): {e}");
         return;
     };
 
     if let Err(e) = cmap::set_string(handle, "test.test_string", "Hello from Rust") {
-        println!("Error in CMAP set_string: {}", e);
+        println!("Error in CMAP set_string: {e}");
         return;
     };
 
     let test_d = cmap::Data::UInt64(0xdeadbeefbacecafe);
     if let Err(e) = cmap::set(handle, "test.test_data", &test_d) {
-        println!("Error in CMAP set_data: {}", e);
+        println!("Error in CMAP set_data: {e}");
         return;
     };
 
     //    let test_d2 = cmap::Data::UInt32(6809);
     let test_d2 = cmap::Data::String("Test string in data 12345".to_string());
     if let Err(e) = cmap::set(handle, "test.test_again", &test_d2) {
-        println!("Error in CMAP set_data2: {}", e);
+        println!("Error in CMAP set_data2: {e}");
         return;
     };
 
     // get them back again
     match cmap::get(handle, "test.test_uint32") {
         Ok(v) => {
-            println!("GOT uint32 {}", v);
+            println!("GOT uint32 {v}");
         }
 
         Err(e) => {
-            println!("Error in CMAP get: {}", e);
+            println!("Error in CMAP get: {e}");
             return;
         }
     };
     match cmap::get(handle, "test.test_int16") {
         Ok(v) => {
-            println!("GOT uint16 {}", v);
+            println!("GOT uint16 {v}");
         }
 
         Err(e) => {
-            println!("Error in CMAP get: {}", e);
+            println!("Error in CMAP get: {e}");
             return;
         }
     };
 
     match cmap::get(handle, "test.test_num_1") {
         Ok(v) => {
-            println!("GOT num {}", v);
+            println!("GOT num {v}");
         }
 
         Err(e) => {
-            println!("Error in CMAP get: {}", e);
+            println!("Error in CMAP get: {e}");
             return;
         }
     };
     match cmap::get(handle, "test.test_num_2") {
         Ok(v) => {
-            println!("GOT num {}", v);
+            println!("GOT num {v}");
         }
 
         Err(e) => {
-            println!("Error in CMAP get: {}", e);
+            println!("Error in CMAP get: {e}");
             return;
         }
     };
     match cmap::get(handle, "test.test_string") {
         Ok(v) => {
-            println!("GOT string {}", v);
+            println!("GOT string {v}");
         }
 
         Err(e) => {
-            println!("Error in CMAP get: {}", e);
+            println!("Error in CMAP get: {e}");
             return;
         }
     };
 
     match cmap::get(handle, "test.test_data") {
         Ok(v) => match v {
-            cmap::Data::UInt64(u) => println!("GOT data value {:x}", u),
-            _ => println!("ERROR type was not UInt64, got {}", v),
+            cmap::Data::UInt64(u) => println!("GOT data value {u:x}"),
+            _ => println!("ERROR type was not UInt64, got {v}"),
         },
 
         Err(e) => {
-            println!("Error in CMAP get: {}", e);
+            println!("Error in CMAP get: {e}");
             return;
         }
     };
@@ -142,18 +139,18 @@ fn main() {
     match cmap::CmapIterStart::new(handle, "totem.") {
         Ok(cmap_iter) => {
             for i in cmap_iter {
-                println!("ITER: {:?}", i);
+                println!("ITER: {i:?}");
             }
             println!();
         }
         Err(e) => {
-            println!("Error in CMAP iter start: {}", e);
+            println!("Error in CMAP iter start: {e}");
         }
     }
 
     // Close this handle
     if let Err(e) = cmap::finalize(handle) {
-        println!("Error in CMAP get: {}", e);
+        println!("Error in CMAP get: {e}");
         return;
     };
 
@@ -161,7 +158,7 @@ fn main() {
     let handle = match cmap::initialize(cmap::Map::Stats) {
         Ok(h) => h,
         Err(e) => {
-            println!("Error in CMAP (Stats) init: {}", e);
+            println!("Error in CMAP (Stats) init: {e}");
             return;
         }
     };
@@ -178,7 +175,7 @@ fn main() {
     ) {
         Ok(th) => th,
         Err(e) => {
-            println!("Error in CMAP track_add {}", e);
+            println!("Error in CMAP track_add {e}");
             return;
         }
     };
@@ -187,7 +184,7 @@ fn main() {
     let mut event_num = 0;
     loop {
         if let Err(e) = cmap::dispatch(handle, corosync::DispatchFlags::One) {
-            println!("Error from CMAP dispatch: {}", e);
+            println!("Error from CMAP dispatch: {e}");
         }
         // Just do 5
         event_num += 1;

bindings/rust/tests/src/bin/cpg-test.rs

@@ -13,16 +13,15 @@ fn deliver_fn(
     msg_len: usize,
 ) {
     println!(
-        "TEST deliver_fn called for {}, from nodeid/pid {}/{}. len={}",
-        group_name, nodeid, pid, msg_len
+        "TEST deliver_fn called for {group_name}, from nodeid/pid {nodeid}/{pid}. len={msg_len}"
     );
 
     // Print as text if it's valid UTF8
     match str::from_utf8(msg) {
-        Ok(s) => println!("  {}", s),
+        Ok(s) => println!("  {s}"),
         Err(_) => {
             for i in msg {
-                print!("{:02x} ", i);
+                print!("{i:02x} ");
             }
             println!();
         }
@@ -36,10 +35,10 @@ fn confchg_fn(
     left_list: Vec<cpg::Address>,
     joined_list: Vec<cpg::Address>,
 ) {
-    println!("TEST confchg_fn called for {}", group_name);
-    println!("  members: {:?}", member_list);
-    println!("  left:    {:?}", left_list);
-    println!("  joined:  {:?}", joined_list);
+    println!("TEST confchg_fn called for {group_name}");
+    println!("  members: {member_list:?}");
+    println!("  left:    {left_list:?}");
+    println!("  joined:  {joined_list:?}");
 }
 
 fn totem_confchg_fn(_handle: &cpg::Handle, ring_id: cpg::RingId, member_list: Vec<NodeId>) {
@@ -47,7 +46,7 @@ fn totem_confchg_fn(_handle: &cpg::Handle, ring_id: cpg::RingId, member_list: Ve
         "TEST totem_confchg_fn called for {}/{}",
         ring_id.nodeid, ring_id.seq
     );
-    println!("  members: {:?}", member_list);
+    println!("  members: {member_list:?}");
 }
 
 fn main() {
@@ -62,40 +61,40 @@ fn main() {
     let handle = match cpg::initialize(&md, 99_u64) {
         Ok(h) => h,
         Err(e) => {
-            println!("Error in CPG init: {}", e);
+            println!("Error in CPG init: {e}");
             return;
         }
     };
 
     if let Err(e) = cpg::join(handle, "TEST") {
-        println!("Error in CPG join: {}", e);
+        println!("Error in CPG join: {e}");
         return;
     }
 
     match cpg::local_get(handle) {
         Ok(n) => {
-            println!("Local nodeid is {}", n);
+            println!("Local nodeid is {n}");
         }
         Err(e) => {
-            println!("Error in CPG local_get: {}", e);
+            println!("Error in CPG local_get: {e}");
         }
     }
 
     // Test membership_get()
     match cpg::membership_get(handle, "TEST") {
         Ok(m) => {
-            println!("  members: {:?}", m);
+            println!("  members: {m:?}");
             println!();
         }
         Err(e) => {
-            println!("Error in CPG membership_get: {}", e);
+            println!("Error in CPG membership_get: {e}");
         }
     }
 
     // Test context APIs
     let set_context: u64 = 0xabcdbeefcafe;
     if let Err(e) = cpg::context_set(handle, set_context) {
-        println!("Error in CPG context_set: {}", e);
+        println!("Error in CPG context_set: {e}");
         return;
     }
 
@@ -103,14 +102,11 @@ fn main() {
     match cpg::context_get(handle) {
         Ok(c) => {
             if c != set_context {
-                println!(
-                    "Error: context_get() returned {:x}, context should be {:x}",
-                    c, set_context
-                );
+                println!("Error: context_get() returned {c:x}, context should be {set_context:x}");
             }
         }
         Err(e) => {
-            println!("Error in CPG context_get: {}", e);
+            println!("Error in CPG context_get: {e}");
         }
     }
 
@@ -118,12 +114,12 @@ fn main() {
     match cpg::CpgIterStart::new(handle, "", cpg::CpgIterType::All) {
         Ok(cpg_iter) => {
             for i in cpg_iter {
-                println!("ITER: {:?}", i);
+                println!("ITER: {i:?}");
             }
             println!();
         }
         Err(e) => {
-            println!("Error in CPG iter start: {}", e);
+            println!("Error in CPG iter start: {e}");
         }
     }
 
@@ -133,7 +129,7 @@ fn main() {
         cpg::Guarantee::TypeAgreed,
         &"This is a test".to_string().into_bytes(),
     ) {
-        println!("Error in CPG mcast_joined: {}", e);
+        println!("Error in CPG mcast_joined: {e}");
     }
 
     // Wait for events

bindings/rust/tests/src/bin/quorum-test.rs

@@ -9,9 +9,9 @@ fn quorum_fn(
     ring_id: quorum::RingId,
     member_list: Vec<NodeId>,
 ) {
-    println!("TEST quorum_fn called. quorate = {}", quorate);
+    println!("TEST quorum_fn called. quorate = {quorate}");
     println!("  ring_id: {}/{}", ring_id.nodeid, ring_id.seq);
-    println!("  members: {:?}", member_list);
+    println!("  members: {member_list:?}");
 }
 
 fn nodelist_fn(
@@ -25,9 +25,9 @@ fn nodelist_fn(
         "TEST nodelist_fn called for {}/{}",
         ring_id.nodeid, ring_id.seq
     );
-    println!("  members: {:?}", member_list);
-    println!("  joined: {:?}", joined_list);
-    println!("  left: {:?}", left_list);
+    println!("  members: {member_list:?}");
+    println!("  joined: {joined_list:?}");
+    println!("  left: {left_list:?}");
 }
 
 fn main() {
@@ -44,7 +44,7 @@ fn main() {
             h
         }
         Err(e) => {
-            println!("Error in QUORUM init: {}", e);
+            println!("Error in QUORUM init: {e}");
             return;
         }
     };
@@ -52,7 +52,7 @@ fn main() {
     // Test context APIs
     let set_context: u64 = 0xabcdbeefcafe;
     if let Err(e) = quorum::context_set(handle, set_context) {
-        println!("Error in QUORUM context_set: {}", e);
+        println!("Error in QUORUM context_set: {e}");
         return;
     }
 
@@ -60,19 +60,16 @@ fn main() {
     match quorum::context_get(handle) {
         Ok(c) => {
             if c != set_context {
-                println!(
-                    "Error: context_get() returned {:x}, context should be {:x}",
-                    c, set_context
-                );
+                println!("Error: context_get() returned {c:x}, context should be {set_context:x}");
             }
         }
         Err(e) => {
-            println!("Error in QUORUM context_get: {}", e);
+            println!("Error in QUORUM context_get: {e}");
         }
     }
 
     if let Err(e) = quorum::trackstart(handle, corosync::TrackFlags::Changes) {
-        println!("Error in QUORUM trackstart: {}", e);
+        println!("Error in QUORUM trackstart: {e}");
         return;
     }
 

bindings/rust/tests/src/bin/votequorum-test.rs

@@ -9,8 +9,8 @@ fn quorum_fn(
     quorate: bool,
     member_list: Vec<votequorum::Node>,
 ) {
-    println!("TEST votequorum_quorum_fn called. quorate = {}", quorate);
-    println!("  members: {:?}", member_list);
+    println!("TEST votequorum_quorum_fn called. quorate = {quorate}");
+    println!("  members: {member_list:?}");
 }
 
 fn nodelist_fn(
@@ -23,11 +23,11 @@ fn nodelist_fn(
         "TEST nodelist_fn called for {}/{}",
         ring_id.nodeid, ring_id.seq
     );
-    println!("  members: {:?}", member_list);
+    println!("  members: {member_list:?}");
 }
 
 fn expectedvotes_fn(_handle: &votequorum::Handle, _context: u64, expected_votes: u32) {
-    println!("TEST expected_votes_fn called: value is {}", expected_votes);
+    println!("TEST expected_votes_fn called: value is {expected_votes}");
 }
 
 fn main() {
@@ -44,7 +44,7 @@ fn main() {
             h
         }
         Err(e) => {
-            println!("Error in VOTEQUORUM init: {}", e);
+            println!("Error in VOTEQUORUM init: {e}");
             return;
         }
     };
@@ -52,28 +52,25 @@ fn main() {
     // Test context APIs
     let set_context: u64 = 0xabcdbeefcafe;
     if let Err(e) = votequorum::context_set(handle, set_context) {
-        println!("Error in VOTEQUORUM context_set: {}", e);
+        println!("Error in VOTEQUORUM context_set: {e}");
     }
 
     // NOTE This will fail on 32 bit systems because void* is not u64
     match votequorum::context_get(handle) {
         Ok(c) => {
             if c != set_context {
-                println!(
-                    "Error: context_get() returned {:x}, context should be {:x}",
-                    c, set_context
-                );
+                println!("Error: context_get() returned {c:x}, context should be {set_context:x}");
             }
         }
         Err(e) => {
-            println!("Error in VOTEQUORUM context_get: {}", e);
+            println!("Error in VOTEQUORUM context_get: {e}");
         }
     }
 
     const QDEVICE_NAME: &str = "RustQdevice";
 
     if let Err(e) = votequorum::qdevice_register(handle, QDEVICE_NAME) {
-        println!("Error in VOTEQUORUM qdevice_register: {}", e);
+        println!("Error in VOTEQUORUM qdevice_register: {e}");
     }
 
     match votequorum::get_info(handle, corosync::NodeId::from(1u32)) {
@@ -97,19 +94,16 @@ fn main() {
             }
         }
         Err(e) => {
-            println!(
-                "Error in VOTEQUORUM get_info: {} (check nodeid 1 has been online)",
-                e
-            );
+            println!("Error in VOTEQUORUM get_info: {e} (check nodeid 1 has been online)");
         }
     }
 
     if let Err(e) = votequorum::qdevice_unregister(handle, QDEVICE_NAME) {
-        println!("Error in VOTEQUORUM qdevice_unregister: {}", e);
+        println!("Error in VOTEQUORUM qdevice_unregister: {e}");
     }
 
     if let Err(e) = votequorum::trackstart(handle, 99_u64, corosync::TrackFlags::Changes) {
-        println!("Error in VOTEQUORUM trackstart: {}", e);
+        println!("Error in VOTEQUORUM trackstart: {e}");
         return;
     }