Increase usage of implicit named arguments in format strings

crates/ruma-appservice-api/src/event/push_events.rs

@@ -90,7 +90,7 @@ pub mod v1 {
                     let join = response.rooms.join.entry(room_id).or_default();
                     join.timeline.events.push(Raw::from_json(event_json));
                 } else {
-                    warn!("Event without room_id: {}", event_json);
+                    warn!("Event without room_id: {event_json}");
                 }
             }
 

crates/ruma-client-api/src/session/get_login_types.rs

@@ -363,7 +363,7 @@ pub mod v3 {
 
             let mut identity_providers = match flow {
                 Some(LoginType::Sso(SsoLoginType { identity_providers })) => identity_providers,
-                _ => panic!("unexpected enum variant: {:?}", flow),
+                _ => panic!("unexpected enum variant: {flow:?}"),
             };
 
             let provider = identity_providers.pop();

crates/ruma-client-api/src/state/get_state_events_for_key.rs

@@ -97,12 +97,10 @@ pub mod v3 {
                     &METADATA,
                     None,
                     Some(format_args!(
-                        "/_matrix/client/r0/rooms/{}/state/{}",
+                        "/_matrix/client/r0/rooms/{room_id_percent}/state/{event_type_percent}",
-                        room_id_percent, event_type_percent
                     )),
                     Some(format_args!(
-                        "/_matrix/client/v3/rooms/{}/state/{}",
+                        "/_matrix/client/v3/rooms/{room_id_percent}/state/{event_type_percent}",
-                        room_id_percent, event_type_percent
                     )),
                 )?
             );

crates/ruma-client-api/src/state/send_state_event.rs

@@ -125,12 +125,10 @@ pub mod v3 {
                     &METADATA,
                     None,
                     Some(format_args!(
-                        "/_matrix/client/r0/rooms/{}/state/{}",
+                        "/_matrix/client/r0/rooms/{room_id_percent}/state/{event_type_percent}",
-                        room_id_percent, event_type_percent
                     )),
                     Some(format_args!(
-                        "/_matrix/client/v3/rooms/{}/state/{}",
+                        "/_matrix/client/v3/rooms/{room_id_percent}/state/{event_type_percent}",
-                        room_id_percent, event_type_percent
                     )),
                 )?
             );

crates/ruma-client-api/src/uiaa.rs

@@ -717,7 +717,7 @@ impl fmt::Display for UiaaResponse {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::AuthResponse(_) => write!(f, "User-Interactive Authentication required."),
-            Self::MatrixError(err) => write!(f, "{}", err),
+            Self::MatrixError(err) => write!(f, "{err}"),
         }
     }
 }

crates/ruma-client/build.rs

@@ -11,7 +11,7 @@ fn main() {
         eprintln!("error: Only one tls features can be enabled.");
 
         for (f, a) in &tls_features {
-            eprintln!("  {}: {}", f, if *a { "enabled" } else { "disabled" });
+            eprintln!("  {f}: {}", if *a { "enabled" } else { "disabled" });
         }
 
         process::exit(1);

crates/ruma-client/src/error.rs

@@ -30,10 +30,10 @@ impl<E: Display, F: Display> Display for Error<E, F> {
             Self::AuthenticationRequired => {
                 write!(f, "The queried endpoint requires authentication but was called with an anonymous client.")
             }
-            Self::IntoHttp(err) => write!(f, "HTTP request construction failed: {}", err),
+            Self::IntoHttp(err) => write!(f, "HTTP request construction failed: {err}"),
-            Self::Url(err) => write!(f, "Invalid URL: {}", err),
+            Self::Url(err) => write!(f, "Invalid URL: {err}"),
-            Self::Response(err) => write!(f, "Couldn't obtain a response: {}", err),
+            Self::Response(err) => write!(f, "Couldn't obtain a response: {err}"),
-            Self::FromHttpResponse(err) => write!(f, "HTTP response conversion failed: {}", err),
+            Self::FromHttpResponse(err) => write!(f, "HTTP response conversion failed: {err}"),
         }
     }
 }

crates/ruma-client/src/lib.rs

@@ -187,8 +187,8 @@ fn add_user_id_to_query<C: HttpClient + ?Sized, R: OutgoingRequest>(
         let extra_params = urlencoded::to_string(&[("user_id", user_id)]).unwrap();
         let uri = http_request.uri_mut();
         let new_path_and_query = match uri.query() {
-            Some(params) => format!("{}?{}&{}", uri.path(), params, extra_params),
+            Some(params) => format!("{}?{params}&{extra_params}", uri.path()),
-            None => format!("{}?{}", uri.path(), extra_params),
+            None => format!("{}?{extra_params}", uri.path()),
         };
         *uri = Uri::from_parts(assign!(uri.clone().into_parts(), {
             path_and_query: Some(new_path_and_query.parse()?),

crates/ruma-common/src/api.rs

@@ -309,10 +309,10 @@ pub trait OutgoingRequestAppserviceExt: OutgoingRequest {
 
         let path_and_query_with_user_id = match &parts.path_and_query {
             Some(path_and_query) => match path_and_query.query() {
-                Some(_) => format!("{}&{}", path_and_query, user_id_query),
+                Some(_) => format!("{path_and_query}&{user_id_query}"),
-                None => format!("{}?{}", path_and_query, user_id_query),
+                None => format!("{path_and_query}?{user_id_query}"),
             },
-            None => format!("/?{}", user_id_query),
+            None => format!("/?{user_id_query}"),
         };
 
         parts.path_and_query =

crates/ruma-common/src/api/error.rs

@@ -161,8 +161,8 @@ impl<E, F> FromHttpResponseError<Result<E, F>> {
 impl<E: fmt::Display> fmt::Display for FromHttpResponseError<E> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Deserialization(err) => write!(f, "deserialization failed: {}", err),
+            Self::Deserialization(err) => write!(f, "deserialization failed: {err}"),
-            Self::Server(err) => write!(f, "the server returned an error: {}", err),
+            Self::Server(err) => write!(f, "the server returned an error: {err}"),
         }
     }
 }

crates/ruma-common/src/api/metadata.rs

@@ -225,6 +225,6 @@ impl MatrixVersion {
 impl Display for MatrixVersion {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let (major, minor) = self.into_parts();
-        f.write_str(&format!("v{}.{}", major, minor))
+        f.write_str(&format!("v{major}.{minor}"))
     }
 }

crates/ruma-common/src/events/room/join_rules.rs

@@ -274,7 +274,7 @@ mod tests {
                     AllowRule::room_membership(room_id!("!users:example.org").to_owned())
                 ]
             ),
-            rule => panic!("Deserialized to wrong variant: {:?}", rule),
+            rule => panic!("Deserialized to wrong variant: {rule:?}"),
         }
     }
 

crates/ruma-common/src/events/room/name.rs

@@ -135,7 +135,7 @@ mod tests {
         let from_raw: Raw<RoomNameEventContent> = from_json_value(long_content_json).unwrap();
 
         let result = from_raw.deserialize();
-        assert!(result.is_err(), "Result should be invalid: {:?}", result);
+        assert!(result.is_err(), "Result should be invalid: {result:?}");
     }
 
     #[test]

crates/ruma-common/src/identifiers/matrix_uri.rs

@@ -139,7 +139,7 @@ impl MatrixId {
                 "roomid" => '!',
                 _ => return Err(MatrixIdError::UnknownType.into()),
             };
-            id = format!("{}/{}{}", id, sigil, id_without_sigil);
+            id = format!("{id}/{sigil}{id_without_sigil}");
         }
 
         Self::parse_with_sigil(&id)
@@ -462,7 +462,7 @@ impl MatrixUri {
 
 impl fmt::Display for MatrixUri {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}:{}", MATRIX_SCHEME, self.id().to_string_with_type())?;
+        write!(f, "{MATRIX_SCHEME}:{}", self.id().to_string_with_type())?;
 
         let mut first = true;
         for server_name in &self.via {

crates/ruma-common/src/identifiers/user_id.rs

@@ -51,7 +51,7 @@ impl UserId {
             Self::parse(id).map(Into::into)
         } else {
             let _ = localpart_is_fully_conforming(id_str)?;
-            Ok(Self::from_borrowed(&format!("@{}:{}", id_str, server_name)).to_owned())
+            Ok(Self::from_borrowed(&format!("@{id_str}:{server_name}")).to_owned())
         }
     }
 
@@ -68,7 +68,7 @@ impl UserId {
             Self::parse_rc(id)
         } else {
             let _ = localpart_is_fully_conforming(id_str)?;
-            Ok(Self::from_rc(format!("@{}:{}", id_str, server_name).into()))
+            Ok(Self::from_rc(format!("@{id_str}:{server_name}").into()))
         }
     }
 
@@ -85,7 +85,7 @@ impl UserId {
             Self::parse_arc(id)
         } else {
             let _ = localpart_is_fully_conforming(id_str)?;
-            Ok(Self::from_arc(format!("@{}:{}", id_str, server_name).into()))
+            Ok(Self::from_arc(format!("@{id_str}:{server_name}").into()))
         }
     }
 

crates/ruma-common/src/push/condition.rs

@@ -288,13 +288,13 @@ impl FlattenedJson {
         match value {
             JsonValue::Object(fields) => {
                 for (key, value) in fields {
-                    let path = if path.is_empty() { key } else { format!("{}.{}", path, key) };
+                    let path = if path.is_empty() { key } else { format!("{path}.{key}") };
                     self.flatten_value(value, path);
                 }
             }
             JsonValue::String(s) => {
                 if self.map.insert(path.clone(), s).is_some() {
-                    warn!("Duplicate path in flattened JSON: {}", path);
+                    warn!("Duplicate path in flattened JSON: {path}");
                 }
             }
             JsonValue::Number(_) | JsonValue::Bool(_) | JsonValue::Array(_) | JsonValue::Null => {}

crates/ruma-common/src/push/condition/room_member_count_is.rs

@@ -115,7 +115,7 @@ impl fmt::Display for RoomMemberCountIs {
             Op::Le => "<=",
         };
 
-        write!(f, "{}{}", prefix, self.count)
+        write!(f, "{prefix}{}", self.count)
     }
 }
 

crates/ruma-common/src/serde/canonical_json.rs

@@ -22,7 +22,7 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Error::IntConvert => f.write_str("number found is not a valid `js_int::Int`"),
-            Error::SerDe(err) => write!(f, "serde Error: {}", err),
+            Error::SerDe(err) => write!(f, "serde Error: {err}"),
         }
     }
 }

crates/ruma-common/src/serde/canonical_json/value.rs

@@ -317,7 +317,7 @@ mod tests {
         let json: CanonicalJsonValue =
             json!({ "city": "London", "street": "10 Downing Street" }).try_into().unwrap();
 
-        assert_eq!(format!("{}", json), CANONICAL_STR);
+        assert_eq!(format!("{json}"), CANONICAL_STR);
         assert_eq!(format!("{:#}", json), CANONICAL_STR);
     }
 }

crates/ruma-common/src/serde/urlencoded/de.rs

@@ -77,7 +77,7 @@ where
     let mut buf = vec![];
     reader
         .read_to_end(&mut buf)
-        .map_err(|e| de::Error::custom(format_args!("could not read input: {}", e)))?;
+        .map_err(|e| de::Error::custom(format_args!("could not read input: {e}")))?;
     from_bytes(&buf)
 }
 

crates/ruma-common/src/serde/urlencoded/ser.rs

@@ -60,7 +60,7 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Error::Custom(ref msg) => msg.fmt(f),
-            Error::Utf8(ref err) => write!(f, "invalid UTF-8: {}", err),
+            Error::Utf8(ref err) => write!(f, "invalid UTF-8: {err}"),
         }
     }
 }
@@ -85,7 +85,7 @@ impl error::Error for Error {
 
 impl ser::Error for Error {
     fn custom<T: fmt::Display>(msg: T) -> Self {
-        Error::Custom(format!("{}", msg).into())
+        Error::Custom(format!("{msg}").into())
     }
 }
 

crates/ruma-common/src/to_device.rs

@@ -25,7 +25,7 @@ pub enum DeviceIdOrAllDevices {
 impl Display for DeviceIdOrAllDevices {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         match self {
-            DeviceIdOrAllDevices::DeviceId(device_id) => write!(f, "{}", device_id),
+            DeviceIdOrAllDevices::DeviceId(device_id) => write!(f, "{device_id}"),
             DeviceIdOrAllDevices::AllDevices => write!(f, "*"),
         }
     }

crates/ruma-common/tests/api/select_path.rs

@@ -31,7 +31,7 @@ const R: &str = "r";
 fn select_stable() {
     let meta = Metadata { added: Some(V1_1), ..BASE };
 
-    let res = select_path(&[V1_0, V1_1], &meta, None, None, Some(format_args!("{}", S)))
+    let res = select_path(&[V1_0, V1_1], &meta, None, None, Some(format_args!("{S}")))
         .unwrap()
         .to_string();
 
@@ -43,7 +43,7 @@ fn select_unstable() {
     let meta = BASE;
 
     let res =
-        select_path(&[V1_0], &meta, Some(format_args!("{}", U)), None, None).unwrap().to_string();
+        select_path(&[V1_0], &meta, Some(format_args!("{U}")), None, None).unwrap().to_string();
 
     assert_eq!(res, U);
 }
@@ -53,7 +53,7 @@ fn select_r0() {
     let meta = Metadata { added: Some(V1_0), ..BASE };
 
     let res =
-        select_path(&[V1_0], &meta, None, Some(format_args!("{}", R)), Some(format_args!("{}", S)))
+        select_path(&[V1_0], &meta, None, Some(format_args!("{R}")), Some(format_args!("{S}")))
             .unwrap()
             .to_string();
 
@@ -67,9 +67,9 @@ fn select_removed_err() {
     let res = select_path(
         &[V1_2],
         &meta,
-        Some(format_args!("{}", U)),
+        Some(format_args!("{U}")),
-        Some(format_args!("{}", R)),
+        Some(format_args!("{R}")),
-        Some(format_args!("{}", S)),
+        Some(format_args!("{S}")),
     )
     .unwrap_err();
 
@@ -81,7 +81,7 @@ fn partially_removed_but_stable() {
     let meta = Metadata { added: Some(V1_0), deprecated: Some(V1_1), removed: Some(V1_2), ..BASE };
 
     let res =
-        select_path(&[V1_1], &meta, None, Some(format_args!("{}", R)), Some(format_args!("{}", S)))
+        select_path(&[V1_1], &meta, None, Some(format_args!("{R}")), Some(format_args!("{S}")))
             .unwrap()
             .to_string();
 
@@ -93,7 +93,7 @@ fn no_unstable() {
     let meta = Metadata { added: Some(V1_1), ..BASE };
 
     let res =
-        select_path(&[V1_0], &meta, None, Some(format_args!("{}", R)), Some(format_args!("{}", S)))
+        select_path(&[V1_0], &meta, None, Some(format_args!("{R}")), Some(format_args!("{S}")))
             .unwrap_err();
 
     assert_matches!(res, IntoHttpError::NoUnstablePath);

crates/ruma-common/tests/events/location.rs

@@ -164,7 +164,7 @@ fn zoomlevel_deserialization_too_high() {
         from_json_value::<LocationContent>(json_data),
         Err(err)
             if err.is_data()
-            && format!("{}", err) == format!("{}", ZoomLevelError::TooHigh)
+            && format!("{err}") == format!("{}", ZoomLevelError::TooHigh)
     );
 }
 

crates/ruma-common/tests/events/state_event.rs

@@ -287,7 +287,7 @@ fn deserialize_full_event_convert_to_sync() {
     let full_ev: AnyStateEvent = from_json_value(json_data).unwrap();
     let sync_ev = match AnySyncStateEvent::from(full_ev) {
         AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(ev)) => ev,
-        ev => panic!("unexpected variant for event {:?}", ev),
+        ev => panic!("unexpected variant for event {ev:?}"),
     };
 
     assert_eq!(sync_ev.content.aliases, vec![room_alias_id!("#somewhere:localhost")]);

crates/ruma-macros/src/api/version.rs

@@ -28,11 +28,11 @@ impl Parse for MatrixVersionLiteral {
         })?;
 
         let major: NonZeroU8 = ver[0].parse().map_err(|e| {
-            Error::new_spanned(&fl, format!("major number failed to parse as >0 number: {}", e))
+            Error::new_spanned(&fl, format!("major number failed to parse as >0 number: {e}"))
         })?;
         let minor: u8 = ver[1]
             .parse()
-            .map_err(|e| Error::new_spanned(&fl, format!("minor number failed to parse: {}", e)))?;
+            .map_err(|e| Error::new_spanned(&fl, format!("minor number failed to parse: {e}")))?;
 
         Ok(Self { major, minor })
     }

crates/ruma-macros/src/events/event_content.rs

@@ -329,7 +329,7 @@ fn generate_redacted_event_content<'a>(
     let serde_json = quote! { #ruma_common::exports::serde_json };
 
     let doc = format!("Redacted form of [`{}`]", ident);
-    let redacted_ident = format_ident!("Redacted{}", ident);
+    let redacted_ident = format_ident!("Redacted{ident}");
 
     let kept_redacted_fields: Vec<_> = fields
         .map(|f| {
@@ -493,7 +493,7 @@ fn generate_event_type_aliases(
     .iter()
     .filter_map(|&var| Some((var, event_kind.to_event_ident(var).ok()?)))
     .map(|(var, ev_struct)| {
-        let ev_type = format_ident!("{}{}", var, ev_type_s);
+        let ev_type = format_ident!("{var}{ev_type_s}");
 
         let doc_text = match var {
             EventKindVariation::None | EventKindVariation::Original => "",
@@ -510,7 +510,7 @@ fn generate_event_type_aliases(
         let ev_type_doc = format!("An `{}` event{}.", event_type, doc_text);
 
         let content_struct = if var.is_redacted() {
-            Cow::Owned(format_ident!("Redacted{}", ident))
+            Cow::Owned(format_ident!("Redacted{ident}"))
         } else {
             Cow::Borrowed(ident)
         };

crates/ruma-macros/src/events/event_enum.rs

@@ -811,14 +811,14 @@ impl EventEnumVariation {
     pub fn to_sync(self) -> Self {
         match self {
             EventEnumVariation::None => EventEnumVariation::Sync,
-            _ => panic!("No sync form of {:?}", self),
+            _ => panic!("No sync form of {self:?}"),
         }
     }
 
     pub fn to_full(self) -> Self {
         match self {
             EventEnumVariation::Sync => EventEnumVariation::None,
-            _ => panic!("No full form of {:?}", self),
+            _ => panic!("No full form of {self:?}"),
         }
     }
 }

crates/ruma-macros/src/events/event_parse.rs

@@ -59,7 +59,7 @@ impl EventKindVariation {
         match self {
             EventKindVariation::Original => EventKindVariation::Redacted,
             EventKindVariation::OriginalSync => EventKindVariation::RedactedSync,
-            _ => panic!("No redacted form of {:?}", self),
+            _ => panic!("No redacted form of {self:?}"),
         }
     }
 
@@ -67,7 +67,7 @@ impl EventKindVariation {
         match self {
             EventKindVariation::OriginalSync => EventKindVariation::Original,
             EventKindVariation::RedactedSync => EventKindVariation::Redacted,
-            _ => panic!("No original (unredacted) form of {:?}", self),
+            _ => panic!("No original (unredacted) form of {self:?}"),
         }
     }
 }
@@ -135,7 +135,7 @@ impl EventKind {
                 Self::MessageLike | Self::RoomRedaction | Self::State,
                 V::Original | V::OriginalSync | V::Redacted | V::RedactedSync,
             )
-            | (Self::State, V::Stripped | V::Initial) => Ok(format_ident!("{}{}", var, self)),
+            | (Self::State, V::Stripped | V::Initial) => Ok(format_ident!("{var}{self}")),
             _ => Err(syn::Error::new(
                 Span::call_site(),
                 format!(

crates/ruma-macros/src/identifiers.rs

@@ -25,7 +25,7 @@ impl Parse for IdentifierInput {
 
 pub fn expand_id_zst(input: ItemStruct) -> syn::Result<TokenStream> {
     let id = &input.ident;
-    let owned = format_ident!("Owned{}", id);
+    let owned = format_ident!("Owned{id}");
 
     let owned_decl = expand_owned_id(&input);
 
@@ -222,9 +222,9 @@ pub fn expand_id_zst(input: ItemStruct) -> syn::Result<TokenStream> {
 
 fn expand_owned_id(input: &ItemStruct) -> TokenStream {
     let id = &input.ident;
-    let owned = format_ident!("Owned{}", id);
+    let owned = format_ident!("Owned{id}");
 
-    let doc_header = format!("Owned variant of {}", id);
+    let doc_header = format!("Owned variant of {id}");
     let (impl_generics, ty_generics, _where_clause) = input.generics.split_for_impl();
 
     let id_ty = quote! { #id #ty_generics };
@@ -405,7 +405,7 @@ fn expand_owned_id(input: &ItemStruct) -> TokenStream {
 
 fn expand_checked_impls(input: &ItemStruct, validate: Path) -> TokenStream {
     let id = &input.ident;
-    let owned = format_ident!("Owned{}", id);
+    let owned = format_ident!("Owned{id}");
 
     let (impl_generics, ty_generics, _where_clause) = input.generics.split_for_impl();
     let generic_params = &input.generics.params;
@@ -553,7 +553,7 @@ fn expand_checked_impls(input: &ItemStruct, validate: Path) -> TokenStream {
 
 fn expand_unchecked_impls(input: &ItemStruct) -> TokenStream {
     let id = &input.ident;
-    let owned = format_ident!("Owned{}", id);
+    let owned = format_ident!("Owned{id}");
 
     quote! {
         impl<'a> From<&'a str> for &'a #id {

crates/ruma-macros/src/util.rs

@@ -5,16 +5,16 @@ use syn::{Ident, LitStr};
 
 pub(crate) fn import_ruma_common() -> TokenStream {
     if let Ok(FoundCrate::Name(name)) = crate_name("ruma-common") {
-        let import = format_ident!("{}", name);
+        let import = format_ident!("{name}");
         quote! { ::#import }
     } else if let Ok(FoundCrate::Name(name)) = crate_name("ruma") {
-        let import = format_ident!("{}", name);
+        let import = format_ident!("{name}");
         quote! { ::#import }
     } else if let Ok(FoundCrate::Name(name)) = crate_name("matrix-sdk") {
-        let import = format_ident!("{}", name);
+        let import = format_ident!("{name}");
         quote! { ::#import::ruma }
     } else if let Ok(FoundCrate::Name(name)) = crate_name("matrix-sdk-appservice") {
-        let import = format_ident!("{}", name);
+        let import = format_ident!("{name}");
         quote! { ::#import::ruma }
     } else {
         quote! { ::ruma_common }

crates/ruma-signatures/src/functions.rs

@@ -1104,7 +1104,7 @@ mod tests {
         if let Error::Verification(VerificationError::PublicKeyNotFound(entity)) = error_msg {
             assert_eq!(entity, "domain-sender");
         } else {
-            panic!("Error was not VerificationError::UnknownPublicKeysForEvent: {:?}", error_msg);
+            panic!("Error was not VerificationError::UnknownPublicKeysForEvent: {error_msg:?}");
         };
     }
 
@@ -1152,11 +1152,9 @@ mod tests {
         if let Error::Verification(VerificationError::Signature(error)) = error_msg {
             // dalek doesn't expose InternalError :(
             // https://github.com/dalek-cryptography/ed25519-dalek/issues/174
-            assert!(
+            assert!(format!("{error:?}").contains("Some(Verification equation was not satisfied)"));
-                format!("{:?}", error).contains("Some(Verification equation was not satisfied)")
-            );
         } else {
-            panic!("Error was not VerificationError::Signature: {:?}", error_msg);
+            panic!("Error was not VerificationError::Signature: {error_msg:?}");
         };
     }
 

crates/ruma-state-res/benches/state_res_bench.rs

@@ -79,7 +79,7 @@ fn resolution_shallow_auth_chain(c: &mut Criterion) {
                 |id| ev_map.get(id).map(Arc::clone),
             ) {
                 Ok(state) => state,
-                Err(e) => panic!("{}", e),
+                Err(e) => panic!("{e}"),
             };
         });
     });

crates/ruma-state-res/src/event_auth.rs

@@ -263,7 +263,7 @@ pub fn auth_check<E: Event>(
         }
 
         let target_user =
-            <&UserId>::try_from(state_key).map_err(|e| Error::InvalidPdu(format!("{}", e)))?;
+            <&UserId>::try_from(state_key).map_err(|e| Error::InvalidPdu(format!("{e}")))?;
 
         let user_for_join_auth =
             content.join_authorised_via_users_server.as_ref().and_then(|u| u.deserialize().ok());
@@ -697,7 +697,7 @@ fn valid_membership_change(
 fn can_send_event(event: impl Event, ple: Option<impl Event>, user_level: Int) -> bool {
     let event_type_power_level = get_send_level(event.event_type(), event.state_key(), ple);
 
-    debug!("{} ev_type {} usr {}", event.event_id(), event_type_power_level, user_level);
+    debug!("{} ev_type {event_type_power_level} usr {user_level}", event.event_id());
 
     if user_level < event_type_power_level {
         return false;
@@ -722,7 +722,7 @@ fn check_power_levels(
     match power_event.state_key() {
         Some("") => {}
         Some(key) => {
-            error!("m.room.power_levels event has non-empty state key: {}", key);
+            error!("m.room.power_levels event has non-empty state key: {key}");
             return None;
         }
         None => {
@@ -756,7 +756,7 @@ fn check_power_levels(
         user_levels_to_check.insert(user);
     }
 
-    debug!("users to check {:?}", user_levels_to_check);
+    debug!("users to check {user_levels_to_check:?}");
 
     let mut event_levels_to_check = BTreeSet::new();
     let old_list = &current_content.events;
@@ -765,7 +765,7 @@ fn check_power_levels(
         event_levels_to_check.insert(ev_id);
     }
 
-    debug!("events to check {:?}", event_levels_to_check);
+    debug!("events to check {event_levels_to_check:?}");
 
     let old_state = &current_content;
     let new_state = &user_content;

crates/ruma-state-res/src/lib.rs

@@ -70,7 +70,7 @@ where
     let (clean, conflicting) = separate(state_sets.into_iter());
 
     info!("non conflicting events: {}", clean.len());
-    trace!("{:?}", clean);
+    trace!("{clean:?}");
 
     if conflicting.is_empty() {
         info!("no conflicting state found");
@@ -78,7 +78,7 @@ where
     }
 
     info!("conflicting events: {}", conflicting.len());
-    debug!("{:?}", conflicting);
+    debug!("{conflicting:?}");
 
     // `all_conflicted` contains unique items
     // synapse says `full_set = {eid for eid in full_conflicted_set if eid in event_map}`
@@ -89,7 +89,7 @@ where
         .collect();
 
     info!("full conflicted set: {}", all_conflicted.len());
-    debug!("{:?}", all_conflicted);
+    debug!("{all_conflicted:?}");
 
     // We used to check that all events are events from the correct room
     // this is now a check the caller of `resolve` must make.
@@ -106,7 +106,7 @@ where
         reverse_topological_power_sort(control_events, &all_conflicted, &fetch_event)?;
 
     debug!("sorted control events: {}", sorted_control_levels.len());
-    trace!("{:?}", sorted_control_levels);
+    trace!("{sorted_control_levels:?}");
 
     let room_version = RoomVersion::new(room_version)?;
     // Sequentially auth check each control event.
@@ -114,7 +114,7 @@ where
         iterative_auth_check(&room_version, &sorted_control_levels, clean.clone(), &fetch_event)?;
 
     debug!("resolved control events: {}", resolved_control.len());
-    trace!("{:?}", resolved_control);
+    trace!("{resolved_control:?}");
 
     // At this point the control_events have been resolved we now have to
     // sort the remaining events using the mainline of the resolved power level.
@@ -129,16 +129,16 @@ where
         .collect::<Vec<_>>();
 
     debug!("events left to resolve: {}", events_to_resolve.len());
-    trace!("{:?}", events_to_resolve);
+    trace!("{events_to_resolve:?}");
 
     // This "epochs" power level event
     let power_event = resolved_control.get(&(StateEventType::RoomPowerLevels, "".into()));
 
-    debug!("power event: {:?}", power_event);
+    debug!("power event: {power_event:?}");
 
     let sorted_left_events = mainline_sort(&events_to_resolve, power_event.cloned(), &fetch_event)?;
 
-    trace!("events left, sorted: {:?}", sorted_left_events);
+    trace!("events left, sorted: {sorted_left_events:?}");
 
     let mut resolved_state = iterative_auth_check(
         &room_version,
@@ -230,7 +230,7 @@ fn reverse_topological_power_sort<E: Event>(
     let mut event_to_pl = HashMap::new();
     for event_id in graph.keys() {
         let pl = get_power_level_for_sender(event_id.borrow(), &fetch_event)?;
-        info!("{} power level {}", event_id, pl);
+        info!("{event_id} power level {pl}");
 
         event_to_pl.insert(event_id.clone(), pl);
 
@@ -361,7 +361,7 @@ fn get_power_level_for_sender<E: Event>(
     event_id: &EventId,
     fetch_event: impl Fn(&EventId) -> Option<E>,
 ) -> serde_json::Result<Int> {
-    info!("fetch event ({}) senders power level", event_id);
+    info!("fetch event ({event_id}) senders power level");
 
     let event = fetch_event(event_id);
     let mut pl = None;
@@ -382,7 +382,7 @@ fn get_power_level_for_sender<E: Event>(
 
     if let Some(ev) = event {
         if let Some(&user_level) = content.users.get(ev.sender()) {
-            debug!("found {} at power_level {}", ev.sender(), user_level);
+            debug!("found {} at power_level {user_level}", ev.sender());
             return Ok(user_level);
         }
     }
@@ -407,13 +407,13 @@ fn iterative_auth_check<E: Event + Clone>(
 ) -> Result<StateMap<E::Id>> {
     info!("starting iterative auth check");
 
-    debug!("performing auth checks on {:?}", events_to_check);
+    debug!("performing auth checks on {events_to_check:?}");
 
     let mut resolved_state = unconflicted_state;
 
     for event_id in events_to_check {
         let event = fetch_event(event_id.borrow())
-            .ok_or_else(|| Error::NotFound(format!("Failed to find {}", event_id)))?;
+            .ok_or_else(|| Error::NotFound(format!("Failed to find {event_id}")))?;
         let state_key = event
             .state_key()
             .ok_or_else(|| Error::InvalidPdu("State event had no state key".to_owned()))?;
@@ -430,7 +430,7 @@ fn iterative_auth_check<E: Event + Clone>(
                     ev,
                 );
             } else {
-                warn!("auth event id for {} is missing {}", aid, event_id);
+                warn!("auth event id for {aid} is missing {event_id}");
             }
         }
 
@@ -463,7 +463,7 @@ fn iterative_auth_check<E: Event + Clone>(
             resolved_state.insert(event.event_type().with_state_key(state_key), event_id.clone());
         } else {
             // synapse passes here on AuthError. We do not add this event to resolved_state.
-            warn!("event {} failed the authentication check", event_id);
+            warn!("event {event_id} failed the authentication check");
         }
 
         // TODO: if these functions are ever made async here
@@ -498,11 +498,11 @@ fn mainline_sort<E: Event>(
         mainline.push(p.clone());
 
         let event = fetch_event(p.borrow())
-            .ok_or_else(|| Error::NotFound(format!("Failed to find {}", p)))?;
+            .ok_or_else(|| Error::NotFound(format!("Failed to find {p}")))?;
         pl = None;
         for aid in event.auth_events() {
             let ev = fetch_event(aid.borrow())
-                .ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
+                .ok_or_else(|| Error::NotFound(format!("Failed to find {aid}")))?;
             if is_type_and_key(&ev, &RoomEventType::RoomPowerLevels, "") {
                 pl = Some(aid.to_owned());
                 break;
@@ -561,7 +561,7 @@ fn get_mainline_depth<E: Event>(
         event = None;
         for aid in sort_ev.auth_events() {
             let aev = fetch_event(aid.borrow())
-                .ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
+                .ok_or_else(|| Error::NotFound(format!("Failed to find {aid}")))?;
             if is_type_and_key(&aev, &RoomEventType::RoomPowerLevels, "") {
                 event = Some(aev);
                 break;
@@ -1079,7 +1079,7 @@ mod tests {
             |id| ev_map.get(id).map(Arc::clone),
         ) {
             Ok(state) => state,
-            Err(e) => panic!("{}", e),
+            Err(e) => panic!("{e}"),
         };
 
         assert_eq!(expected, resolved);
@@ -1179,14 +1179,14 @@ mod tests {
             |id| ev_map.get(id).map(Arc::clone),
         ) {
             Ok(state) => state,
-            Err(e) => panic!("{}", e),
+            Err(e) => panic!("{e}"),
         };
 
         debug!(
             "{:#?}",
             resolved
                 .iter()
-                .map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
+                .map(|((ty, key), id)| format!("(({ty}{key:?}), {id})"))
                 .collect::<Vec<_>>()
         );
 
@@ -1202,7 +1202,7 @@ mod tests {
 
         for id in expected.iter().map(|i| event_id(i)) {
             // make sure our resolved events are equal to the expected list
-            assert!(resolved.values().any(|eid| eid == &id) || init.contains_key(&id), "{}", id);
+            assert!(resolved.values().any(|eid| eid == &id) || init.contains_key(&id), "{id}");
         }
         assert_eq!(expected.len(), resolved.len());
     }

crates/ruma-state-res/src/room_version.rs

@@ -115,7 +115,7 @@ impl RoomVersion {
             RoomVersionId::V7 => Self::V7,
             RoomVersionId::V8 => Self::V8,
             RoomVersionId::V9 => Self::V9,
-            ver => return Err(Error::Unsupported(format!("found version `{}`", ver.as_str()))),
+            ver => return Err(Error::Unsupported(format!("found version `{ver}`"))),
         })
     }
 }

crates/ruma-state-res/src/test_utils.rs

@@ -107,7 +107,7 @@ pub fn do_check(
                     .iter()
                     .map(|map| map
                         .iter()
-                        .map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
+                        .map(|((ty, key), id)| format!("(({ty}{key:?}), {id})"))
                         .collect::<Vec<_>>())
                     .collect::<Vec<_>>()
             );
@@ -124,7 +124,7 @@ pub fn do_check(
             });
             match resolved {
                 Ok(state) => state,
-                Err(e) => panic!("resolution for {} failed: {}", node, e),
+                Err(e) => panic!("resolution for {node} failed: {e}"),
             }
         };
 
@@ -175,8 +175,7 @@ pub fn do_check(
     for node in expected_state_ids {
         let ev = event_map.get(&node).unwrap_or_else(|| {
             panic!(
-                "{} not found in {:?}",
+                "{node} not found in {:?}",
-                node,
                 event_map.keys().map(ToString::to_string).collect::<Vec<_>>()
             )
         });
@@ -214,7 +213,7 @@ impl<E: Event> TestStore<E> {
         self.0
             .get(event_id)
             .map(Arc::clone)
-            .ok_or_else(|| Error::NotFound(format!("{} not found", event_id)))
+            .ok_or_else(|| Error::NotFound(format!("{event_id} not found")))
     }
 
     /// Returns a Vec of the related auth events to the given `event`.
@@ -337,7 +336,7 @@ pub fn event_id(id: &str) -> OwnedEventId {
         return id.try_into().unwrap();
     }
 
-    format!("${}:foo", id).try_into().unwrap()
+    format!("${id}:foo").try_into().unwrap()
 }
 
 pub fn alice() -> &'static UserId {
@@ -380,7 +379,7 @@ pub fn to_init_pdu_event(
     content: Box<RawJsonValue>,
 ) -> Arc<PduEvent> {
     let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
-    let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
+    let id = if id.contains('$') { id.to_owned() } else { format!("${id}:foo") };
 
     let state_key = state_key.map(ToOwned::to_owned);
     Arc::new(PduEvent {
@@ -416,7 +415,7 @@ where
     S: AsRef<str>,
 {
     let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
-    let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
+    let id = if id.contains('$') { id.to_owned() } else { format!("${id}:foo") };
     let auth_events = auth_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
     let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
 

examples/joke_bot/src/main.rs

@@ -22,7 +22,7 @@ use tokio_stream::StreamExt as _;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     if let Err(e) = run().await {
-        eprintln!("{}", e);
+        eprintln!("{e}");
         exit(1)
     }
     Ok(())
@@ -33,7 +33,7 @@ type MatrixClient = client::Client<client::http_client::HyperNativeTls>;
 
 async fn run() -> Result<(), Box<dyn Error>> {
     let config =
-        read_config().await.map_err(|e| format!("configuration in ./config is invalid: {}", e))?;
+        read_config().await.map_err(|e| format!("configuration in ./config is invalid: {e}"))?;
     let http_client =
         hyper::Client::builder().build::<_, hyper::Body>(hyper_tls::HttpsConnector::new());
     let matrix_client = if let Some(state) = read_state().await.ok().flatten() {
@@ -52,8 +52,7 @@ async fn run() -> Result<(), Box<dyn Error>> {
         {
             eprintln!(
                 "Failed to persist access token to disk. \
-                 Re-authentication will be required on the next startup: {}",
+                 Re-authentication will be required on the next startup: {err}",
-                err
             );
         }
         client
@@ -95,14 +94,14 @@ async fn run() -> Result<(), Box<dyn Error>> {
                 if let Err(err) =
                     handle_message(http_client, matrix_client, e, room_id, user_id).await
                 {
-                    eprintln!("failed to respond to message: {}", err);
+                    eprintln!("failed to respond to message: {err}");
                 }
             }
         });
 
         let invite_futures = response.rooms.invite.iter().map(|(room_id, _)| async move {
             if let Err(err) = handle_invitations(http_client, matrix_client, room_id).await {
-                eprintln!("failed to accept invitation for room {}: {}", &room_id, err);
+                eprintln!("failed to accept invitation for room {room_id}: {err}");
             }
         });
 
@@ -127,14 +126,14 @@ async fn create_matrix_session(
             let reason = match e {
                 client::Error::AuthenticationRequired => "invalid credentials specified".to_owned(),
                 client::Error::Response(response_err) => {
-                    format!("failed to get a response from the server: {}", response_err)
+                    format!("failed to get a response from the server: {response_err}")
                 }
                 client::Error::FromHttpResponse(parse_err) => {
-                    format!("failed to parse log in response: {}", parse_err)
+                    format!("failed to parse log in response: {parse_err}")
                 }
                 _ => e.to_string(),
             };
-            return Err(format!("Failed to log in: {}", reason).into());
+            return Err(format!("Failed to log in: {reason}").into());
         }
 
         Ok(client)
@@ -184,12 +183,12 @@ async fn handle_invitations(
     matrix_client: &MatrixClient,
     room_id: &RoomId,
 ) -> Result<(), Box<dyn Error>> {
-    println!("invited to {}", &room_id);
+    println!("invited to {room_id}");
     matrix_client.send_request(join_room_by_id::v3::Request::new(room_id)).await?;
 
     let greeting = "Hello! My name is Mr. Bot! I like to tell jokes. Like this one: ";
     let joke = get_joke(http_client).await.unwrap_or_else(|_| "err... never mind.".to_owned());
-    let content = RoomMessageEventContent::text_plain(format!("{}\n{}", greeting, joke));
+    let content = RoomMessageEventContent::text_plain(format!("{greeting}\n{joke}"));
     let txn_id = TransactionId::new();
     let message = send_message_event::v3::Request::new(room_id, &txn_id, &content)?;
     matrix_client.send_request(message).await?;
@@ -244,9 +243,10 @@ async fn read_config() -> io::Result<Config> {
                 "homeserver" => homeserver = Some(value.trim().to_owned()),
                 // TODO: infer domain from `homeserver`
                 "username" => {
-                    username = value.trim().to_owned().try_into().map_err(|e| {
+                    username =
-                        format!("invalid Matrix user ID format for `username`: {}", e)
+                        value.trim().to_owned().try_into().map_err(|e| {
-                    });
+                            format!("invalid Matrix user ID format for `username`: {e}")
+                        });
                 }
                 "password" => password = Some(value.trim().to_owned()),
                 _ => {}

examples/message_log/src/main.rs

@@ -58,7 +58,7 @@ async fn log_messages(
                     }),
                 )) = event
                 {
-                    println!("{:?} in {:?}: {}", sender, room_id, msg_body);
+                    println!("{sender} in {room_id}: {msg_body}");
                 }
             }
         }

xtask/src/cargo.rs

@@ -30,7 +30,7 @@ pub struct Package {
 impl Package {
     /// Update the version of this crate.
     pub fn update_version(&mut self, version: &Version, dry_run: bool) -> Result<()> {
-        println!("Updating {} to version {}…", self.name, version);
+        println!("Updating {} to version {version}…", self.name);
 
         if !dry_run {
             let mut document = read_file(&self.manifest_path)?.parse::<Document>()?;
@@ -96,9 +96,9 @@ impl Package {
             ..self.version.clone()
         };
 
-        let update = if changelog.starts_with(&format!("# {}\n", version)) {
+        let update = if changelog.starts_with(&format!("# {version}\n")) {
             false
-        } else if changelog.starts_with(&format!("# {} (unreleased)\n", version))
+        } else if changelog.starts_with(&format!("# {version} (unreleased)\n"))
             || changelog.starts_with("# [unreleased]\n")
         {
             update
@@ -124,12 +124,8 @@ impl Package {
         };
 
         if update {
-            let changelog = format!(
+            let rest = &changelog[changes_end..];
-                "# [unreleased]\n\n# {}\n\n{}\n{}",
+            let changelog = format!("# [unreleased]\n\n# {}\n\n{changes}\n{rest}", self.version);
-                self.version,
-                changes,
-                &changelog[changes_end..]
-            );
 
             write_file(&changelog_path, changelog)?;
         }
@@ -140,7 +136,7 @@ impl Package {
     /// Check if the current version of the crate is published on crates.io.
     pub fn is_published(&self, client: &HttpClient) -> Result<bool> {
         let response: CratesIoCrate =
-            client.get(format!("{}/{}/{}", CRATESIO_API, self.name, self.version))?.json()?;
+            client.get(format!("{CRATESIO_API}/{}/{}", self.name, self.version))?.json()?;
 
         Ok(response.version.is_some())
     }

xtask/src/release.rs

@@ -63,7 +63,7 @@ impl ReleaseTask {
             .clone()
             .into_iter()
             .find(|p| p.name == name)
-            .ok_or(format!("Package {} not found in cargo metadata", name))?;
+            .ok_or(format!("Package {name} not found in cargo metadata"))?;
 
         let config = crate::Config::load()?.github;
 
@@ -87,12 +87,11 @@ impl ReleaseTask {
         let publish_only = self.package.name == "ruma-identifiers-validation";
 
         println!(
-            "Starting {} for {}…",
+            "Starting {} for {title}…",
             match prerelease {
                 true => "pre-release",
                 false => "release",
             },
-            title
         );
 
         if self.is_released()? {
@@ -246,7 +245,7 @@ impl ReleaseTask {
 
         if !self.dry_run {
             let instructions = "Ready to commit the changes. [continue/abort/diff]: ";
-            print!("{}", instructions);
+            print!("{instructions}");
             stdout().flush()?;
 
             let mut handle = stdin.lock();
@@ -272,7 +271,7 @@ impl ReleaseTask {
                         println!("Unknown command.");
                     }
                 }
-                print!("{}", instructions);
+                print!("{instructions}");
                 stdout().flush()?;
 
                 input.clear();
@@ -292,11 +291,8 @@ impl ReleaseTask {
 
     /// Check if the tag for the current version of the crate has been pushed on GitHub.
     fn is_released(&self) -> Result<bool> {
-        let response = self.http_client.get(format!(
+        let response =
-            "{}/releases/tags/{}",
+            self.http_client.get(format!("{GITHUB_API_RUMA}/releases/tags/{}", self.tag_name()))?;
-            GITHUB_API_RUMA,
-            self.tag_name()
-        ))?;
 
         Ok(response.status() == StatusCode::OK)
     }
@@ -400,7 +396,7 @@ impl VersionExt for Version {
     fn increment_pre_number(&mut self) {
         if let Some((prefix, num)) = self.pre.as_str().rsplit_once('.') {
             if let Ok(num) = num.parse::<u8>() {
-                self.pre = semver::Prerelease::new(&format!("{}.{}", prefix, num + 1)).unwrap();
+                self.pre = semver::Prerelease::new(&format!("{prefix}.{}", num + 1)).unwrap();
             }
         }
     }

xtask/src/util.rs

@@ -9,7 +9,7 @@ pub fn ask_yes_no(question: &str) -> Result<bool> {
     let mut input = String::new();
     let stdin = stdin();
 
-    print!("{} [y/N]: ", question);
+    print!("{question} [y/N]: ");
     stdout().flush()?;
 
     let mut handle = stdin.lock();