Used the Formatter::debug_struct() builder instead of string formatting

Author: Michael-F-Bryan

src/basic_block.rs

@@ -421,6 +421,11 @@ impl fmt::Debug for BasicBlock {
             LLVMIsConstant(self.basic_block as LLVMValueRef) == 1
         };
 
-        write!(f, "BasicBlock {{\n    address: {:?}\n    is_const: {:?}\n    llvm_value: {:?}\n    llvm_type: {:?}\n}}", self.basic_block, is_const, llvm_value, llvm_type)
+        f.debug_struct("BasicBlock")
+            .field("address", &self.basic_block)
+            .field("is_const", &is_const)
+            .field("llvm_value", &llvm_value)
+            .field("llvm_type", &llvm_type)
+            .finish()
     }
 }

src/data_layout.rs

@@ -36,9 +36,10 @@ impl PartialEq for DataLayout {
 
 impl fmt::Debug for DataLayout {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "DataLayout {{\n    ")?;
-        write!(f, "address: {:?}\n    ", self.data_layout.get())?;
-        write!(f, "repr: {:?}\n}}", self.as_str())
+        f.debug_struct("DataLayout")
+            .field("address", &self.data_layout.get())
+            .field("repr", &self.as_str())
+            .finish()
     }
 }
 

src/types/fn_type.rs

@@ -82,7 +82,10 @@ impl fmt::Debug for FunctionType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let llvm_type = self.print_to_string();
 
-        write!(f, "FunctionType {{\n    address: {:?}\n    llvm_type: {:?}\n}}", self.as_type_ref(), llvm_type)
+        f.debug_struct("FunctionType")
+            .field("address", &self.as_type_ref())
+            .field("llvm_type", &llvm_type)
+            .finish()
     }
 }
 

src/types/mod.rs

@@ -171,6 +171,9 @@ impl fmt::Debug for Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let llvm_type = self.print_to_string();
 
-        write!(f, "Type {{\n    address: {:?}\n    llvm_type: {:?}\n}}", self.type_, llvm_type)
+        f.debug_struct("Type")
+            .field("address", &self.type_)
+            .field("llvm_type", &llvm_type)
+            .finish()
     }
 }

src/values/array_value.rs

@@ -93,6 +93,15 @@ impl fmt::Debug for ArrayValue {
             !LLVMIsAConstantDataArray(self.as_value_ref()).is_null()
         };
 
-        write!(f, "Value {{\n    name: {:?}\n    address: {:?}\n    is_const: {:?}\n    is_const_array: {:?}\n    is_const_data_array: {:?}\n    is_null: {:?}\n    llvm_value: {:?}\n    llvm_type: {:?}\n}}", name, self.as_value_ref(), is_const, is_const_array, is_const_data_array, is_null, llvm_value, llvm_type.print_to_string())
+        f.debug_struct("Value")
+            .field("name", &name)
+            .field("address", &self.as_value_ref())
+            .field("is_const", &is_const)
+            .field("is_const_array", &is_const_array)
+            .field("is_const_data_array", &is_const_data_array)
+            .field("is_null", &is_null)
+            .field("llvm_value", &llvm_value)
+            .field("llvm_type",  &llvm_type)
+            .finish()
     }
 }

src/values/metadata_value.rs

@@ -143,17 +143,17 @@ impl AsValueRef for MetadataValue {
 
 impl fmt::Debug for MetadataValue {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "MetadataValue {{\n    ")?;
-        write!(f, "address: {:?}\n", self.as_value_ref())?;
+        let mut d = f.debug_struct("MetadataValue");
+        d.field("address", &self.as_value_ref());
 
         if self.is_string() {
-            write!(f, "value: {:?}\n", self.get_string_value().unwrap())?;
+            d.field("value", &self.get_string_value().unwrap());
         } else {
-            write!(f, "values: {:?}\n", self.get_node_values())?;
+            d.field("values", &self.get_node_values());
         }
 
-        write!(f, "repr: {:?}", self.print_to_string())?;
+        d.field("repr", &self.print_to_string());
 
-        write!(f, "\n}}")
+        d.finish()
     }
 }

src/values/mod.rs

@@ -168,6 +168,14 @@ impl fmt::Debug for Value {
         let is_null = self.is_null();
         let is_undef = self.is_undef();
 
-        write!(f, "Value {{\n    name: {:?}\n    address: {:?}\n    is_const: {:?}\n    is_null: {:?}\n    is_undef: {:?}\n    llvm_value: {:?}\n    llvm_type: {:?}\n}}", name, self.value, is_const, is_null, is_undef, llvm_value, llvm_type)
+        f.debug_struct("Value")
+            .field("name", &name)
+            .field("address", &self.value)
+            .field("is_const", &is_const)
+            .field("is_null", &is_null)
+            .field("is_undef", &is_undef)
+            .field("llvm_value", &llvm_value)
+            .field("llvm_type", &llvm_type)
+            .finish()
     }
 }