Add a convenience function for displaying a BlockCall (#5677)

Add a display method to BlockCall that returns a std::fmt::Displayable result. Rework the display code in the write module of cranelift-codegen to use this method instead.

cranelift/codegen/src/ir/instructions.rs

@@ -118,6 +118,35 @@ impl BlockCall {
     {
         self.values.extend(elements, pool)
     }
+
+    /// Return a value that can display this block call.
+    pub fn display<'a>(&self, pool: &'a ValueListPool) -> DisplayBlockCall<'a> {
+        DisplayBlockCall { block: *self, pool }
+    }
+}
+
+/// Wrapper for the context needed to display a [BlockCall] value.
+pub struct DisplayBlockCall<'a> {
+    block: BlockCall,
+    pool: &'a ValueListPool,
+}
+
+impl<'a> Display for DisplayBlockCall<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.block.block(&self.pool))?;
+        let args = self.block.args_slice(&self.pool);
+        if !args.is_empty() {
+            write!(f, "(")?;
+            for (ix, arg) in args.iter().enumerate() {
+                if ix > 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{}", arg)?;
+            }
+            write!(f, ")")?;
+        }
+        Ok(())
+    }
 }
 
 // Include code generated by `cranelift-codegen/meta/src/gen_inst.rs`. This file contains:

cranelift/codegen/src/write.rs

@@ -415,18 +415,15 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
         IntAddTrap { args, code, .. } => write!(w, " {}, {}, {}", args[0], args[1], code),
         FloatCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
         Jump { destination, .. } => {
-            write!(w, " {}", destination.block(pool))?;
+            write!(w, " {}", destination.display(pool))
-            write_block_args(w, destination.args_slice(pool))
         }
         Brif {
             arg,
             blocks: [block_then, block_else],
             ..
         } => {
-            write!(w, " {}, {}", arg, block_then.block(pool))?;
+            write!(w, " {}, {}", arg, block_then.display(pool))?;
-            write_block_args(w, block_then.args_slice(pool))?;
+            write!(w, ", {}", block_else.display(pool))
-            write!(w, ", {}", block_else.block(pool))?;
-            write_block_args(w, block_else.args_slice(pool))
         }
         BranchTable {
             arg,
@@ -500,15 +497,6 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
     Ok(())
 }
 
-/// Write block args using optional parantheses.
-fn write_block_args(w: &mut dyn Write, args: &[Value]) -> fmt::Result {
-    if args.is_empty() {
-        Ok(())
-    } else {
-        write!(w, "({})", DisplayValues(args))
-    }
-}
-
 /// Displayable slice of values.
 struct DisplayValues<'a>(&'a [Value]);