Formatting fixes

Author: oisyn

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1179,9 +1179,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         flags: MemFlags,
     ) -> Self::Value {
         if flags != MemFlags::empty() {
-            self.err(&format!(
-                "store_with_flags is not supported yet: {flags:?}"
-            ));
+            self.err(&format!("store_with_flags is not supported yet: {flags:?}"));
         }
         self.store(val, ptr, align)
     }

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -64,9 +64,7 @@ impl<'a, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         const SUPPORTED_OPTIONS: InlineAsmOptions = InlineAsmOptions::NORETURN;
         let unsupported_options = options & !SUPPORTED_OPTIONS;
         if !unsupported_options.is_empty() {
-            self.err(&format!(
-                "asm flags not supported: {unsupported_options:?}"
-            ));
+            self.err(&format!("asm flags not supported: {unsupported_options:?}"));
         }
         // vec of lines, and each line is vec of tokens
         let mut tokens = vec![vec![]];
@@ -102,10 +100,9 @@ impl<'a, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'tcx> {
                     span,
                 } => {
                     if let Some(modifier) = modifier {
-                        self.tcx.sess.span_err(
-                            span,
-                            format!("asm modifiers are not supported: {modifier}"),
-                        );
+                        self.tcx
+                            .sess
+                            .span_err(span, format!("asm modifiers are not supported: {modifier}"));
                     }
                     let line = tokens.last_mut().unwrap();
                     let typeof_kind = line.last().and_then(|prev| match prev {
@@ -373,9 +370,7 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                     }
                     AsmBlock::End(terminator) => {
                         if op != Op::Label {
-                            self.err(&format!(
-                                "expected OpLabel after terminator {terminator:?}"
-                            ));
+                            self.err(&format!("expected OpLabel after terminator {terminator:?}"));
                         }
 
                         AsmBlock::Open
@@ -1146,9 +1141,7 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                             }
                         },
                         Some(Token::String(_)) => {
-                            self.err(&format!(
-                                "expected a literal, not a string for a {kind:?}"
-                            ));
+                            self.err(&format!("expected a literal, not a string for a {kind:?}"));
                         }
                         Some(Token::Placeholder(_, span)) => {
                             self.tcx.sess.span_err(
@@ -1339,24 +1332,18 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                 Ok(x) => inst
                     .operands
                     .push(dr::Operand::RayQueryCommittedIntersectionType(x)),
-                Err(()) => self.err(&format!(
-                    "unknown RayQueryCommittedIntersectionType {word}"
-                )),
+                Err(()) => self.err(&format!("unknown RayQueryCommittedIntersectionType {word}")),
             },
             (OperandKind::RayQueryCandidateIntersectionType, Some(word)) => match word.parse() {
                 Ok(x) => inst
                     .operands
                     .push(dr::Operand::RayQueryCandidateIntersectionType(x)),
-                Err(()) => self.err(&format!(
-                    "unknown RayQueryCandidateIntersectionType {word}"
-                )),
+                Err(()) => self.err(&format!("unknown RayQueryCandidateIntersectionType {word}")),
             },
             (kind, None) => match token {
                 Token::Word(_) => bug!(),
                 Token::String(_) => {
-                    self.err(&format!(
-                        "expected a literal, not a string for a {kind:?}"
-                    ));
+                    self.err(&format!("expected a literal, not a string for a {kind:?}"));
                 }
                 Token::Placeholder(_, span) => {
                     self.tcx.sess.span_err(

crates/rustc_codegen_spirv/src/linker/specializer.rs

@@ -2308,7 +2308,8 @@ impl<'a, S: Specialization> Expander<'a, S> {
             let func_id = inst.operands[1].unwrap_id_ref();
             assert!(
                 !self.specializer.generics.contains_key(&func_id),
-                "{}", "entry-point %{func_id} shouldn't be \"generic\""
+                "{}",
+                "entry-point %{func_id} shouldn't be \"generic\""
             );
 
             for interface_operand in &mut inst.operands[3..] {

crates/spirv-builder/src/lib.rs

@@ -406,7 +406,8 @@ fn join_checking_for_separators(strings: Vec<impl Borrow<str>>, sep: &str) -> St
         let s = s.borrow();
         assert!(
             !s.contains(sep),
-            "{}", "{s:?} may not contain separator {sep:?}"
+            "{}",
+            "{s:?} may not contain separator {sep:?}"
         );
     }
     strings.join(sep)