Update clippy suggestions

Author: Schottkyc137

vhdl_lang/src/analysis/declarative.rs

@@ -1349,8 +1349,8 @@ fn pretty_format_unassociated_message(unassociated: &HashSet<&RecordElement<'_>>
         desc
     };
     if unassociated.len() == 1 {
-        format!("Missing association of element {}", description)
+        format!("Missing association of element {description}")
     } else {
-        format!("Missing association of elements {}", description)
+        format!("Missing association of elements {description}")
     }
 }

vhdl_lang/src/analysis/overloaded.rs

@@ -312,7 +312,7 @@ impl<'a> AnalyzeContext<'a, '_> {
         } else if ok_kind.is_empty() {
             diagnostics.add(
                 call_name.pos(self.ctx),
-                format!("uninstantiated subprogram {} cannot be called", call_name),
+                format!("uninstantiated subprogram {call_name} cannot be called"),
                 ErrorCode::InvalidCall,
             );
             return Err(EvalError::Unknown);

vhdl_lang/src/ast/display.rs

@@ -628,7 +628,7 @@ impl Display for Designator {
             Designator::Identifier(ref sym) => write!(f, "{sym}"),
             Designator::OperatorSymbol(ref op) => write!(f, "\"{op}\""),
             Designator::Character(byte) => write!(f, "'{}'", iso_8859_1_to_utf8(&[*byte])),
-            Designator::Anonymous(idx) => write!(f, "<anonymous {}>", idx),
+            Designator::Anonymous(idx) => write!(f, "<anonymous {idx}>"),
         }
     }
 }
@@ -765,7 +765,7 @@ impl Display for ObjectDeclaration {
             self.class,
             self.idents
                 .iter()
-                .map(|ident| format!("{}", ident))
+                .map(|ident| format!("{ident}"))
                 .join(", "),
             self.subtype_indication,
         )?;
@@ -916,7 +916,7 @@ impl Display for SubprogramInstantiation {
         write!(f, " is new ")?;
         write!(f, "{}", self.subprogram_name)?;
         if let Some(signature) = &self.signature {
-            write!(f, " {}", signature)?;
+            write!(f, " {signature}")?;
         }
         if let Some(generic_map) = &self.generic_map {
             writeln!(f, " generic map (")?;

vhdl_lang/src/completion/entity_instantiation.rs

@@ -277,7 +277,7 @@ end arch;
                 _ => None,
             })
             .collect_vec();
-        println!("{:?}", applicable_options);
+        println!("{applicable_options:?}");
         match &applicable_options[..] {
             [(got_ent, architectures)] => {
                 pretty_assertions::assert_eq!(*got_ent, ent);

vhdl_lang/src/config.rs

@@ -78,8 +78,7 @@ impl Config {
         for (name, lib) in libs.iter() {
             if name.to_lowercase() == "work" {
                 return Err(format!(
-                    "The '{}' library is not a valid library.\nHint: To use a library that contains all files, use a common name for all libraries, i.e., 'defaultlib'",
-                    name
+                    "The '{name}' library is not a valid library.\nHint: To use a library that contains all files, use a common name for all libraries, i.e., 'defaultlib'"
                 ));
             }
 

vhdl_lang/src/named_entity/formal_region.rs

@@ -190,7 +190,7 @@ impl<'a> FormalRegion<'a> {
         if let Some(ent) = InterfaceEnt::from_any(param) {
             self.entities.push(ent);
         } else {
-            println!("kind: {:?}", param);
+            println!("kind: {param:?}");
             debug_assert!(false);
         }
     }

vhdl_lang/src/syntax/test.rs

@@ -873,7 +873,7 @@ pub fn check_diagnostics(got: Vec<Diagnostic>, expected: Vec<Diagnostic>) {
                     println!("Got right diagnostic but wrong count {got_count}, expected {count}");
                     println!("-------------------------------------------------------");
                     print!("{}: ", diagnostic.code);
-                    println!("{:?}", diagnostic);
+                    println!("{diagnostic:?}");
                 }
             }
             None => {
@@ -882,7 +882,7 @@ pub fn check_diagnostics(got: Vec<Diagnostic>, expected: Vec<Diagnostic>) {
                 println!("Got no diagnostic, expected {count}");
                 println!("-------------------------------------------------------");
                 print!("{}: ", diagnostic.code);
-                println!("{:?}", diagnostic);
+                println!("{diagnostic:?}");
             }
         }
     }
@@ -893,7 +893,7 @@ pub fn check_diagnostics(got: Vec<Diagnostic>, expected: Vec<Diagnostic>) {
         println!("Got unexpected diagnostic");
         println!("-------------------------------------------------------");
         print!("{}: ", diagnostic.code);
-        println!("{:?}", diagnostic);
+        println!("{diagnostic:?}");
     }
 
     if found_errors {

vhdl_lang/src/syntax/tokens/tokenizer.rs

@@ -563,7 +563,7 @@ impl Display for TokenSpan {
 
 impl Debug for TokenSpan {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self)
+        write!(f, "{self}")
     }
 }
 
@@ -2732,7 +2732,7 @@ my_other_ident",
         // May not use digit larger than or equal base
         let code = Code::new("3#3#");
         let (tokens, _) = code.tokenize_result();
-        println!("{:?}", tokens);
+        println!("{tokens:?}");
         assert_eq!(
             tokens,
             vec![Err(Diagnostic::syntax_error(

vhdl_ls/src/stdio_server.rs

@@ -43,7 +43,7 @@ impl RpcChannel for ConnectionRpcChannel {
     fn send_notification(&self, method: String, params: Value) {
         let notification = lsp_server::Notification { method, params };
 
-        trace!("Sending notification: {:?}", notification);
+        trace!("Sending notification: {notification:?}");
         self.connection.sender.send(notification.into()).unwrap();
     }
 
@@ -84,7 +84,7 @@ impl ConnectionRpcChannel {
     fn main_event_loop(&self, mut server: VHDLServer) {
         info!("Language server initialized, waiting for messages ...");
         while let Ok(message) = self.connection.receiver.recv() {
-            trace!("Received message: {:?}", message);
+            trace!("Received message: {message:?}");
             match message {
                 lsp_server::Message::Request(request) => {
                     match self.connection.handle_shutdown(&request) {
@@ -110,7 +110,7 @@ impl ConnectionRpcChannel {
 
     /// Send responses (to requests sent by the client) back to the client.
     fn send_response(&self, response: lsp_server::Response) {
-        trace!("Sending response: {:?}", response);
+        trace!("Sending response: {response:?}");
         self.connection.sender.send(response.into()).unwrap();
     }
 
@@ -131,7 +131,7 @@ impl ConnectionRpcChannel {
             })
         }
 
-        trace!("Handling request: {:?}", request);
+        trace!("Handling request: {request:?}");
         let request = match extract::<request::GotoDeclaration>(request) {
             Ok((id, params)) => {
                 let result =
@@ -231,7 +231,7 @@ impl ConnectionRpcChannel {
             Err(request) => request,
         };
 
-        debug!("Unhandled request: {:?}", request);
+        debug!("Unhandled request: {request:?}");
         self.send_response(lsp_server::Response::new_err(
             request.id,
             lsp_server::ErrorCode::MethodNotFound as i32,
@@ -256,7 +256,7 @@ impl ConnectionRpcChannel {
             })
         }
 
-        trace!("Handling notification: {:?}", notification);
+        trace!("Handling notification: {notification:?}");
         // textDocument/didChange
         let notification = match extract::<notification::DidChangeTextDocument>(notification) {
             Ok(params) => return server.text_document_did_change_notification(&params),
@@ -279,13 +279,13 @@ impl ConnectionRpcChannel {
         };
 
         if !notification.method.starts_with("$/") {
-            debug!("Unhandled notification: {:?}", notification);
+            debug!("Unhandled notification: {notification:?}");
         }
     }
 
     /// Handle incoming responses (to requests sent by us) from the client.
     fn handle_response(&self, _server: &mut VHDLServer, response: lsp_server::Response) {
-        trace!("Handling response: {:?}", response);
+        trace!("Handling response: {response:?}");
         // We currently can ignore incoming responses as the implemented
         // outgoing requests do not require confirmation by the client.
     }

vhdl_ls/src/vhdl_server/completion.rs

@@ -84,7 +84,7 @@ impl VHDLServer {
                     let (ports, generics) = region.ports_and_generics();
                     let mut idx = 4;
                     let mut interface_ent = |elements: Vec<InterfaceEnt>, purpose: &str| {
-                        line += &*format!("\n {} map(\n", purpose);
+                        line += &*format!("\n {purpose} map(\n");
                         for (i, generic) in elements.iter().enumerate() {
                             line += &*format!(
                                 "    {} => ${{{}:{}}}",