New upstream version 1.47.0+dfsg1

[rustc.git] / src / librustc_session / code_stats.rs

diff --git a/src/librustc_session/code_stats.rs b/src/librustc_session/code_stats.rs
index 764d6d8eaee30c0cc478b6f67797aad6d98f2c2d..c263da69c3521131cdb846bbf0a02c4dc650c129 100644 (file)
--- a/src/librustc_session/code_stats.rs
+++ b/src/librustc_session/code_stats.rs
@@ -1,7 +1,7 @@
+use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::sync::Lock;
 use rustc_target::abi::{Align, Size};
-use rustc_data_structures::fx::{FxHashSet};
 use std::cmp::{self, Ordering};
-use rustc_data_structures::sync::Lock;
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct VariantInfo {
@@ -51,26 +51,26 @@ pub struct CodeStats {
 }
 
 impl CodeStats {
-    pub fn record_type_size<S: ToString>(&self,
-                                         kind: DataTypeKind,
-                                         type_desc: S,
-                                         align: Align,
-                                         overall_size: Size,
-                                         packed: bool,
-                                         opt_discr_size: Option<Size>,
-                                         mut variants: Vec<VariantInfo>) {
+    pub fn record_type_size<S: ToString>(
+        &self,
+        kind: DataTypeKind,
+        type_desc: S,
+        align: Align,
+        overall_size: Size,
+        packed: bool,
+        opt_discr_size: Option<Size>,
+        mut variants: Vec<VariantInfo>,
+    ) {
         // Sort variants so the largest ones are shown first. A stable sort is
         // used here so that source code order is preserved for all variants
         // that have the same size.
-        variants.sort_by(|info1, info2| {
-            info2.size.cmp(&info1.size)
-        });
+        variants.sort_by(|info1, info2| info2.size.cmp(&info1.size));
         let info = TypeSizeInfo {
             kind,
             type_description: type_desc.to_string(),
             align: align.bytes(),
             overall_size: overall_size.bytes(),
-            packed: packed,
+            packed,
             opt_discr_size: opt_discr_size.map(|s| s.bytes()),
             variants,
         };
@@ -92,13 +92,14 @@ impl CodeStats {
         });
 
         for info in &sorted {
-            println!("print-type-size type: `{}`: {} bytes, alignment: {} bytes",
-                     info.type_description, info.overall_size, info.align);
+            println!(
+                "print-type-size type: `{}`: {} bytes, alignment: {} bytes",
+                info.type_description, info.overall_size, info.align
+            );
             let indent = "    ";
 
             let discr_size = if let Some(discr_size) = info.opt_discr_size {
-                println!("print-type-size {}discriminant: {} bytes",
-                         indent, discr_size);
+                println!("print-type-size {}discriminant: {} bytes", indent, discr_size);
                 discr_size
             } else {
                 0
@@ -121,8 +122,12 @@ impl CodeStats {
                         Some(name) => name.to_owned(),
                         None => i.to_string(),
                     };
-                    println!("print-type-size {}variant `{}`: {} bytes",
-                             indent, name, size - discr_size);
+                    println!(
+                        "print-type-size {}variant `{}`: {} bytes",
+                        indent,
+                        name,
+                        size - discr_size
+                    );
                     "        "
                 } else {
                     assert!(i < 1);
@@ -144,36 +149,44 @@ impl CodeStats {
 
                     if offset > min_offset {
                         let pad = offset - min_offset;
-                        println!("print-type-size {}padding: {} bytes",
-                                 indent, pad);
+                        println!("print-type-size {}padding: {} bytes", indent, pad);
                     }
 
                     if offset < min_offset {
                         // If this happens it's probably a union.
-                        println!("print-type-size {}field `.{}`: {} bytes, \
+                        println!(
+                            "print-type-size {}field `.{}`: {} bytes, \
                                   offset: {} bytes, \
                                   alignment: {} bytes",
-                                 indent, name, size, offset, align);
+                            indent, name, size, offset, align
+                        );
                     } else if info.packed || offset == min_offset {
-                        println!("print-type-size {}field `.{}`: {} bytes",
-                                 indent, name, size);
+                        println!("print-type-size {}field `.{}`: {} bytes", indent, name, size);
                     } else {
                         // Include field alignment in output only if it caused padding injection
-                        println!("print-type-size {}field `.{}`: {} bytes, \
+                        println!(
+                            "print-type-size {}field `.{}`: {} bytes, \
                                   alignment: {} bytes",
-                                 indent, name, size, align);
+                            indent, name, size, align
+                        );
                     }
 
                     min_offset = offset + size;
                 }
             }
 
-            assert!(max_variant_size <= info.overall_size,
-                    "max_variant_size {} !<= {} overall_size",
-                    max_variant_size, info.overall_size);
+            assert!(
+                max_variant_size <= info.overall_size,
+                "max_variant_size {} !<= {} overall_size",
+                max_variant_size,
+                info.overall_size
+            );
             if max_variant_size < info.overall_size {
-                println!("print-type-size {}end padding: {} bytes",
-                         indent, info.overall_size - max_variant_size);
+                println!(
+                    "print-type-size {}end padding: {} bytes",
+                    indent,
+                    info.overall_size - max_variant_size
+                );
             }
         }
     }