Do not format inner attributes twice in the main file

Author: topecongiro

rustfmt-core/rustfmt-lib/src/formatting.rs

@@ -128,14 +128,12 @@ fn format_project(
         should_emit_verbose(input_is_stdin, operation_setting.verbosity, || {
             println!("Formatting {}", path)
         });
-        let is_root = path == main_file;
         format_file(
             &parse_session,
             config,
             &krate,
             path,
             &module,
-            is_root,
             &format_report,
             original_snippet.clone(),
         );
@@ -159,28 +157,16 @@ fn format_file(
     krate: &ast::Crate,
     path: FileName,
     module: &Module<'_>,
-    is_root: bool,
     report: &FormatReport,
     original_snippet: Option<String>,
 ) {
     let snippet_provider = parse_session.snippet_provider(module.as_ref().inner);
     let mut visitor =
         FmtVisitor::from_parse_sess(&parse_session, config, &snippet_provider, report.clone());
     visitor.skip_context.update_with_attrs(&krate.attrs);
-
-    // Format inner attributes if available.
-    if !krate.attrs.is_empty() && is_root {
-        visitor.skip_empty_lines(snippet_provider.end_pos());
-        if visitor.visit_attrs(&krate.attrs, ast::AttrStyle::Inner) {
-            visitor.push_rewrite(module.as_ref().inner, None);
-        } else {
-            visitor.format_separate_mod(module.as_ref(), snippet_provider.end_pos());
-        }
-    } else {
-        visitor.last_pos = snippet_provider.start_pos();
-        visitor.skip_empty_lines(snippet_provider.end_pos());
-        visitor.format_separate_mod(module.as_ref(), snippet_provider.end_pos());
-    };
+    visitor.last_pos = snippet_provider.start_pos();
+    visitor.skip_empty_lines(snippet_provider.end_pos());
+    visitor.format_separate_mod(module, snippet_provider.end_pos());
 
     debug_assert_eq!(
         visitor.line_number,

rustfmt-core/rustfmt-lib/src/formatting/modules.rs

@@ -3,6 +3,7 @@ use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
 use rustc_ast::ast;
+use rustc_ast::attr::HasAttrs;
 use rustc_ast::visit::Visitor;
 use rustc_span::symbol::{self, sym, Symbol};
 use thiserror::Error;
@@ -31,6 +32,29 @@ pub(crate) struct Module<'a> {
     inner_attr: Vec<ast::Attribute>,
 }
 
+impl<'a> Module<'a> {
+    pub(crate) fn new(ast_mod: Cow<'a, ast::Mod>, attrs: &[ast::Attribute]) -> Self {
+        let inner_attr = attrs
+            .iter()
+            .filter(|attr| attr.style == ast::AttrStyle::Inner)
+            .cloned()
+            .collect();
+        Module {
+            ast_mod,
+            inner_attr,
+        }
+    }
+}
+
+impl<'a> HasAttrs for Module<'a> {
+    fn attrs(&self) -> &[ast::Attribute] {
+        &self.inner_attr
+    }
+    fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<ast::Attribute>)) {
+        f(&mut self.inner_attr)
+    }
+}
+
 impl<'a> AsRef<ast::Mod> for Module<'a> {
     fn as_ref(&self) -> &ast::Mod {
         &self.ast_mod
@@ -109,10 +133,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
 
         self.file_map.insert(
             root_filename,
-            Module {
-                ast_mod: Cow::Borrowed(&krate.module),
-                inner_attr: krate.attrs.clone(),
-            },
+            Module::new(Cow::Borrowed(&krate.module), &krate.attrs),
         );
         Ok(self.file_map)
     }
@@ -125,10 +146,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
             if let ast::ItemKind::Mod(ref sub_mod) = module_item.item.kind {
                 self.visit_sub_mod(
                     &module_item.item,
-                    Module {
-                        ast_mod: Cow::Owned(sub_mod.clone()),
-                        inner_attr: module_item.item.attrs.clone(),
-                    },
+                    Module::new(Cow::Owned(sub_mod.clone()), &module_item.item.attrs),
                 )?;
             }
         }
@@ -144,13 +162,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
             }
 
             if let ast::ItemKind::Mod(ref sub_mod) = item.kind {
-                self.visit_sub_mod(
-                    &item,
-                    Module {
-                        ast_mod: Cow::Owned(sub_mod.clone()),
-                        inner_attr: item.attrs.clone(),
-                    },
-                )?;
+                self.visit_sub_mod(&item, Module::new(Cow::Owned(sub_mod.clone()), &item.attrs))?;
             }
         }
         Ok(())
@@ -164,13 +176,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
             }
 
             if let ast::ItemKind::Mod(ref sub_mod) = item.kind {
-                self.visit_sub_mod(
-                    item,
-                    Module {
-                        ast_mod: Cow::Borrowed(sub_mod),
-                        inner_attr: item.attrs.clone(),
-                    },
-                )?;
+                self.visit_sub_mod(item, Module::new(Cow::Borrowed(sub_mod), &item.attrs))?;
             }
         }
         Ok(())
@@ -297,10 +303,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
                 Ok(m) => Ok(Some(SubModKind::External(
                     path,
                     DirectoryOwnership::Owned { relative: None },
-                    Module {
-                        ast_mod: Cow::Owned(m.0),
-                        inner_attr: m.1,
-                    },
+                    Module::new(Cow::Owned(m.0), &m.1),
                 ))),
                 Err(ParserError::ParseError) => Err(ModuleResolutionError {
                     module: mod_name.to_string(),
@@ -342,19 +345,13 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
                     Ok(m) if outside_mods_empty => Ok(Some(SubModKind::External(
                         path,
                         ownership,
-                        Module {
-                            ast_mod: Cow::Owned(m.0),
-                            inner_attr: m.1,
-                        },
+                        Module::new(Cow::Owned(m.0), &m.1),
                     ))),
                     Ok(m) => {
                         mods_outside_ast.push((
                             path.clone(),
                             ownership,
-                            Module {
-                                ast_mod: Cow::Owned(m.0),
-                                inner_attr: m.1,
-                            },
+                            Module::new(Cow::Owned(m.0), &m.1),
                         ));
                         if should_insert {
                             mods_outside_ast.push((path, ownership, sub_mod.clone()));
@@ -457,10 +454,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
             result.push((
                 actual_path,
                 DirectoryOwnership::Owned { relative: None },
-                Module {
-                    ast_mod: Cow::Owned(m.0),
-                    inner_attr: m.1,
-                },
+                Module::new(Cow::Owned(m.0), &m.1),
             ))
         }
         result

rustfmt-core/rustfmt-lib/src/formatting/visitor.rs

@@ -1,10 +1,11 @@
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 
-use rustc_ast::{ast, token::DelimToken, visit};
+use rustc_ast::{ast, attr::HasAttrs, token::DelimToken, visit};
 use rustc_span::{symbol, BytePos, Pos, Span};
 
 use crate::config::{BraceStyle, Config};
+use crate::formatting::modules::Module;
 use crate::formatting::{
     attr::*,
     comment::{rewrite_comment, CodeCharKind, CommentCodeSlices},
@@ -947,10 +948,14 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
         }
     }
 
-    pub(crate) fn format_separate_mod(&mut self, m: &ast::Mod, end_pos: BytePos) {
+    pub(crate) fn format_separate_mod(&mut self, m: &Module<'_>, end_pos: BytePos) {
         self.block_indent = Indent::empty();
-        self.walk_mod_items(m);
-        self.format_missing_with_indent(end_pos);
+        if self.visit_attrs(m.attrs(), ast::AttrStyle::Inner) {
+            self.push_skipped_with_span(m.attrs(), m.as_ref().inner, m.as_ref().inner);
+        } else {
+            self.walk_mod_items(m.as_ref());
+            self.format_missing_with_indent(end_pos);
+        }
     }
 
     pub(crate) fn skip_empty_lines(&mut self, end_pos: BytePos) {