rustfmt

Author: LegNeato

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -1554,16 +1554,22 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                 self.err(format!("TensorClampMode not yet supported: {word}"));
             }
             (OperandKind::TensorAddressingOperands, Some(word)) => {
-                self.err(format!("TensorAddressingOperands not yet supported: {word}"));
+                self.err(format!(
+                    "TensorAddressingOperands not yet supported: {word}"
+                ));
             }
             (OperandKind::FPEncoding, Some(word)) => {
                 self.err(format!("FPEncoding not yet supported: {word}"));
             }
             (OperandKind::NamedMaximumNumberOfRegisters, Some(word)) => {
-                self.err(format!("NamedMaximumNumberOfRegisters not yet supported: {word}"));
+                self.err(format!(
+                    "NamedMaximumNumberOfRegisters not yet supported: {word}"
+                ));
             }
             (OperandKind::MatrixMultiplyAccumulateOperands, Some(word)) => {
-                self.err(format!("MatrixMultiplyAccumulateOperands not yet supported: {word}"));
+                self.err(format!(
+                    "MatrixMultiplyAccumulateOperands not yet supported: {word}"
+                ));
             }
             // Catch-all for any other new operand kinds
             (kind, Some(word)) => {
@@ -1603,10 +1609,7 @@ pub const IMAGE_OPERANDS: &[(&str, ImageOperands)] = &[
     ("Sample", ImageOperands::SAMPLE),
     ("MinLod", ImageOperands::MIN_LOD),
     ("MakeTexelAvailable", ImageOperands::MAKE_TEXEL_AVAILABLE),
-    (
-        "MakeTexelAvailableKHR",
-        ImageOperands::MAKE_TEXEL_AVAILABLE,
-    ),
+    ("MakeTexelAvailableKHR", ImageOperands::MAKE_TEXEL_AVAILABLE),
     ("MakeTexelVisible", ImageOperands::MAKE_TEXEL_VISIBLE),
     ("MakeTexelVisibleKHR", ImageOperands::MAKE_TEXEL_VISIBLE),
     ("NonPrivateTexel", ImageOperands::NON_PRIVATE_TEXEL),
@@ -1689,15 +1692,9 @@ pub const MEMORY_ACCESS: &[(&str, MemoryAccess)] = &[
         MemoryAccess::MAKE_POINTER_AVAILABLE,
     ),
     ("MakePointerVisible", MemoryAccess::MAKE_POINTER_VISIBLE),
-    (
-        "MakePointerVisibleKHR",
-        MemoryAccess::MAKE_POINTER_VISIBLE,
-    ),
+    ("MakePointerVisibleKHR", MemoryAccess::MAKE_POINTER_VISIBLE),
     ("NonPrivatePointer", MemoryAccess::NON_PRIVATE_POINTER),
-    (
-        "NonPrivatePointerKHR",
-        MemoryAccess::NON_PRIVATE_POINTER,
-    ),
+    ("NonPrivatePointerKHR", MemoryAccess::NON_PRIVATE_POINTER),
 ];
 pub const KERNEL_PROFILING_INFO: &[(&str, KernelProfilingInfo)] = &[
     ("None", KernelProfilingInfo::NONE),

crates/rustc_codegen_spirv/src/link.rs

@@ -323,7 +323,13 @@ fn post_link_single_module(
     };
 
     if cg_args.run_spirv_val {
-        do_spirv_val(sess, &spv_binary, &original_module_for_spans, out_filename, val_options);
+        do_spirv_val(
+            sess,
+            &spv_binary,
+            &original_module_for_spans,
+            out_filename,
+            val_options,
+        );
     }
 
     {

crates/rustc_codegen_spirv/src/validation_err.rs

@@ -22,11 +22,7 @@ pub struct ValidationErrorContext<'a> {
 
 impl<'a> ValidationErrorContext<'a> {
     /// Creates a new validation error context.
-    pub fn new(
-        sess: &'a Session,
-        module: Option<&'a Module>,
-        filename: &'a Path,
-    ) -> Self {
+    pub fn new(sess: &'a Session, module: Option<&'a Module>, filename: &'a Path) -> Self {
         let span_regen = module.map(|m| SpanRegenerator::new(sess.source_map(), m));
         Self {
             sess,
@@ -197,7 +193,9 @@ impl<'a> ValidationErrorContext<'a> {
             self.sess.dcx().struct_err(message)
         };
 
-        err.help("ensure struct members are properly aligned according to std140/std430 layout rules");
+        err.help(
+            "ensure struct members are properly aligned according to std140/std430 layout rules",
+        );
         err.note(format!("module `{}`", self.filename.display()));
         err.emit();
     }
@@ -383,7 +381,10 @@ impl<'a> ValidationErrorContext<'a> {
                 for inst in &block.instructions {
                     // Found the instruction that produced the pointer
                     if inst.result_id == Some(pointer_id) && inst.class.opcode == source_opcode {
-                        context_lines.push(format!("       %{} = Op{:?} ...", pointer_id, source_opcode));
+                        context_lines.push(format!(
+                            "       %{} = Op{:?} ...",
+                            pointer_id, source_opcode
+                        ));
                     }
                     // Found instructions using the pointer
                     if matches!(inst.class.opcode, Op::Load | Op::Store) {
@@ -396,9 +397,7 @@ impl<'a> ValidationErrorContext<'a> {
                                         .unwrap_or_default();
                                     context_lines.push(format!(
                                         "    -> {}Op{:?} %{} ...",
-                                        result,
-                                        inst.class.opcode,
-                                        pointer_id
+                                        result, inst.class.opcode, pointer_id
                                     ));
                                 }
                             }
@@ -457,9 +456,10 @@ impl<'a> ValidationErrorContext<'a> {
         let m = self.module?;
 
         // Find the OpVariable
-        let var_inst = m.types_global_values.iter().find(|inst| {
-            inst.class.opcode == Op::Variable && inst.result_id == Some(var_id)
-        })?;
+        let var_inst = m
+            .types_global_values
+            .iter()
+            .find(|inst| inst.class.opcode == Op::Variable && inst.result_id == Some(var_id))?;
 
         // Get the pointer type, then the pointee type
         let ptr_type_id = var_inst.result_type?;