Move macro-stats code to a stats module.

Author: nnethercote

compiler/rustc_expand/src/base.rs

@@ -1167,22 +1167,6 @@ pub struct ExpansionData {
     pub is_trailing_mac: bool,
 }
 
-#[derive(Default)]
-pub struct MacroStat {
-    /// Number of uses of the macro.
-    pub uses: usize,
-
-    /// Net increase in number of lines of code (when pretty-printed), i.e.
-    /// `lines(output) - lines(invocation)`. Can be negative because a macro
-    /// output may be smaller than the invocation.
-    pub lines: isize,
-
-    /// Net increase in number of lines of code (when pretty-printed), i.e.
-    /// `bytes(output) - bytes(invocation)`. Can be negative because a macro
-    /// output may be smaller than the invocation.
-    pub bytes: isize,
-}
-
 /// One of these is made during expansion and incrementally updated as we go;
 /// when a macro expansion occurs, the resulting nodes have the `backtrace()
 /// -> expn_data` of their expansion context stored into their span.
@@ -1207,7 +1191,7 @@ pub struct ExtCtxt<'a> {
     /// not to expand it again.
     pub(super) expanded_inert_attrs: MarkedAttrs,
     /// `-Zmacro-stats` data.
-    pub macro_stats: FxHashMap<(Symbol, MacroKind), MacroStat>,
+    pub macro_stats: FxHashMap<(Symbol, MacroKind), crate::stats::MacroStat>, // njn: quals
 }
 
 impl<'a> ExtCtxt<'a> {

compiler/rustc_expand/src/expand.rs

@@ -25,8 +25,8 @@ use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{UNUSED_ATTRIBUTES, UNUSED_DOC_COMMENTS};
 use rustc_session::parse::feature_err;
 use rustc_session::{Limit, Session};
-use rustc_span::hygiene::{MacroKind, SyntaxContext};
-use rustc_span::{ErrorGuaranteed, ExpnKind, FileName, Ident, LocalExpnId, Span, Symbol, kw, sym};
+use rustc_span::hygiene::SyntaxContext;
+use rustc_span::{ErrorGuaranteed, FileName, Ident, LocalExpnId, Span, sym};
 use smallvec::SmallVec;
 
 use crate::base::*;
@@ -42,6 +42,7 @@ use crate::module::{
     DirOwnership, ParsedExternalMod, mod_dir_path, mod_file_path_from_attr, parse_external_mod,
 };
 use crate::placeholders::{PlaceholderExpander, placeholder};
+use crate::stats::*;
 
 macro_rules! ast_fragments {
     (
@@ -160,7 +161,7 @@ macro_rules! ast_fragments {
                 V::Result::output()
             }
 
-            fn to_string(&self) -> String {
+            pub(crate) fn to_string(&self) -> String {
                 match self {
                     AstFragment::OptExpr(Some(expr)) => pprust::expr_to_string(expr),
                     AstFragment::OptExpr(None) => unreachable!(),
@@ -185,21 +186,6 @@ macro_rules! ast_fragments {
     }
 }
 
-fn elems_to_string<T>(elems: &SmallVec<[T; 1]>, f: impl Fn(&T) -> String) -> String {
-    let mut s = String::new();
-    for (i, elem) in elems.iter().enumerate() {
-        if i > 0 {
-            s.push('\n');
-        }
-        s.push_str(&f(elem));
-    }
-    s
-}
-
-fn unreachable_to_string<T>(_: &T) -> String {
-    unreachable!()
-}
-
 ast_fragments! {
     Expr(P<ast::Expr>) {
         "expression";
@@ -330,7 +316,7 @@ impl AstFragmentKind {
         }
     }
 
-    fn expect_from_annotatables<I: IntoIterator<Item = Annotatable>>(
+    pub(crate) fn expect_from_annotatables<I: IntoIterator<Item = Annotatable>>(
         self,
         items: I,
     ) -> AstFragment {
@@ -757,7 +743,13 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                             let fragment =
                                 self.parse_ast_fragment(tok_result, fragment_kind, &mac.path, span);
                             if macro_stats {
-                                self.update_bang_macro_stats(fragment_kind, span, mac, &fragment);
+                                update_bang_macro_stats(
+                                    self.cx,
+                                    fragment_kind,
+                                    span,
+                                    mac,
+                                    &fragment,
+                                );
                             }
                             fragment
                         }
@@ -777,7 +769,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     };
                     if let Some(fragment) = fragment_kind.make_from(tok_result) {
                         if macro_stats {
-                            self.update_bang_macro_stats(fragment_kind, span, mac, &fragment);
+                            update_bang_macro_stats(self.cx, fragment_kind, span, mac, &fragment);
                         }
                         fragment
                     } else {
@@ -829,7 +821,8 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                                 span,
                             );
                             if macro_stats {
-                                self.update_attr_macro_stats(
+                                update_attr_macro_stats(
+                                    self.cx,
                                     fragment_kind,
                                     span,
                                     &attr_item.path,
@@ -867,7 +860,8 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                             } else {
                                 let fragment = fragment_kind.expect_from_annotatables(items);
                                 if macro_stats {
-                                    self.update_attr_macro_stats(
+                                    update_attr_macro_stats(
+                                        self.cx,
                                         fragment_kind,
                                         span,
                                         &meta.path,
@@ -919,7 +913,13 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     };
                     let fragment = fragment_kind.expect_from_annotatables(items);
                     if macro_stats {
-                        self.update_derive_macro_stats(fragment_kind, span, &meta.path, &fragment);
+                        update_derive_macro_stats(
+                            self.cx,
+                            fragment_kind,
+                            span,
+                            &meta.path,
+                            &fragment,
+                        );
                     }
                     fragment
                 }
@@ -960,136 +960,6 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         })
     }
 
-    fn update_bang_macro_stats(
-        &mut self,
-        fragment_kind: AstFragmentKind,
-        span: Span,
-        mac: P<ast::MacCall>,
-        fragment: &AstFragment,
-    ) {
-        // Does this path match any of the include macros, e.g. `include!`?
-        // Ignore them. They would have large numbers but are entirely
-        // unsurprising and uninteresting.
-        let is_include_path = mac.path == sym::include
-            || mac.path == sym::include_bytes
-            || mac.path == sym::include_str
-            || mac.path == [sym::std, sym::include].as_slice() // std::include
-            || mac.path == [sym::std, sym::include_bytes].as_slice() // std::include_bytes
-            || mac.path == [sym::std, sym::include_str].as_slice(); // std::include_str
-        if is_include_path {
-            return;
-        }
-
-        // The call itself (e.g. `println!("hi")`) is the input. Need to wrap
-        // `mac` in something printable; `ast::Expr` is as good as anything
-        // else.
-        let expr = ast::Expr {
-            id: ast::DUMMY_NODE_ID,
-            kind: ExprKind::MacCall(mac),
-            span: Default::default(),
-            attrs: Default::default(),
-            tokens: None,
-        };
-        let input = pprust::expr_to_string(&expr);
-
-        // Get `mac` back out of `expr`.
-        let ast::Expr { kind: ExprKind::MacCall(mac), .. } = expr else { unreachable!() };
-
-        self.update_macro_stats(MacroKind::Bang, fragment_kind, span, &mac.path, &input, fragment);
-    }
-
-    fn update_attr_macro_stats(
-        &mut self,
-        fragment_kind: AstFragmentKind,
-        span: Span,
-        path: &ast::Path,
-        attr: &ast::Attribute,
-        item: Annotatable,
-        fragment: &AstFragment,
-    ) {
-        // Does this path match `#[derive(...)]` in any of its forms? If so,
-        // ignore it because the individual derives will go through the
-        // `Invocation::Derive` handling separately.
-        let is_derive_path = *path == sym::derive
-            // ::core::prelude::v1::derive
-            || *path == [kw::PathRoot, sym::core, sym::prelude, sym::v1, sym::derive].as_slice();
-        if is_derive_path {
-            return;
-        }
-
-        // The attribute plus the item itself constitute the input, which we
-        // measure.
-        let input = format!(
-            "{}\n{}",
-            pprust::attribute_to_string(attr),
-            fragment_kind.expect_from_annotatables(iter::once(item)).to_string(),
-        );
-        self.update_macro_stats(MacroKind::Attr, fragment_kind, span, path, &input, fragment);
-    }
-
-    fn update_derive_macro_stats(
-        &mut self,
-        fragment_kind: AstFragmentKind,
-        span: Span,
-        path: &ast::Path,
-        fragment: &AstFragment,
-    ) {
-        // Use something like `#[derive(Clone)]` for the measured input, even
-        // though it may have actually appeared in a multi-derive attribute
-        // like `#[derive(Clone, Copy, Debug)]`.
-        let input = format!("#[derive({})]", pprust::path_to_string(path));
-        self.update_macro_stats(MacroKind::Derive, fragment_kind, span, path, &input, fragment);
-    }
-
-    fn update_macro_stats(
-        &mut self,
-        macro_kind: MacroKind,
-        fragment_kind: AstFragmentKind,
-        span: Span,
-        path: &ast::Path,
-        input: &str,
-        fragment: &AstFragment,
-    ) {
-        fn lines_and_bytes(s: &str) -> (usize, usize) {
-            (s.trim_end().split('\n').count(), s.len())
-        }
-
-        // Measure the size of the output by pretty-printing it and counting
-        // the lines and bytes.
-        let name = Symbol::intern(&pprust::path_to_string(path));
-        let output = fragment.to_string();
-        let (in_l, in_b) = lines_and_bytes(input);
-        let (out_l, out_b) = lines_and_bytes(&output);
-
-        // This code is useful for debugging `-Zmacro-stats`. For every
-        // invocation it prints the full input and output.
-        if false {
-            let name = ExpnKind::Macro(macro_kind, name).descr();
-            let crate_name = &self.cx.ecfg.crate_name;
-            let span = self
-                .cx
-                .sess
-                .source_map()
-                .span_to_string(span, rustc_span::FileNameDisplayPreference::Local);
-            eprint!(
-                "\
-                -------------------------------\n\
-                {name}: [{crate_name}] ({fragment_kind:?}) {span}\n\
-                -------------------------------\n\
-                {input}\n\
-                -- ({in_l} lines, {in_b} bytes) --> ({out_l} lines, {out_b} bytes) --\n\
-                {output}\n\
-            "
-            );
-        }
-
-        // The recorded size is the difference between the input and the output.
-        let entry = self.cx.macro_stats.entry((name, macro_kind)).or_insert(MacroStat::default());
-        entry.uses += 1;
-        entry.lines += out_l as isize - in_l as isize;
-        entry.bytes += out_b as isize - in_b as isize;
-    }
-
     #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
     fn gate_proc_macro_attr_item(&self, span: Span, item: &Annotatable) {
         let kind = match item {

compiler/rustc_expand/src/lib.rs

@@ -20,6 +20,7 @@ mod errors;
 mod mbe;
 mod placeholders;
 mod proc_macro_server;
+mod stats;
 
 pub use mbe::macro_rules::compile_declarative_macro;
 pub mod base;