Move formatting-related modules under formatting

Author: topecongiro

rustfmt-core/rustfmt-lib/Cargo.toml

@@ -25,6 +25,7 @@ emitter = [
   "diff",
   "serde",
   "serde_json",
+  "term",
 ]
 
 [dependencies]
@@ -37,7 +38,6 @@ itertools = "0.8"
 lazy_static = "1.0.0"
 log = "0.4"
 regex = "1.0"
-term = "0.6"
 thiserror = "1.0"
 unicode_categories = "0.1.1"
 unicode-segmentation = "1.0.0"
@@ -49,6 +49,7 @@ dirs = { version = "2.0", optional = true }
 rustfmt-config_proc_macro = { version = "0.5", path = "config_proc_macro", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0", optional = true }
+term = { version = "0.6", optional = true }
 toml = { version = "0.5", optional = true }
 
 [target.'cfg(windows)'.dependencies]

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

@@ -12,7 +12,7 @@ use std::rc::Rc;
 
 use thiserror::Error;
 
-use crate::syntux::session::ParseSess;
+use crate::formatting::ParseSess;
 use crate::{config::FileName, FormatReport, FormatResult, NewlineStyle};
 
 pub mod checkstyle;
@@ -165,7 +165,7 @@ where
     let mut has_diff = false;
 
     emitter.emit_header(out)?;
-    for (filename, format_result) in format_report.format_result.borrow().iter() {
+    for (filename, format_result) in format_report.format_result_as_rc().borrow().iter() {
         has_diff |= write_file(None, filename, &format_result, out, &mut *emitter)?.has_diff;
     }
     emitter.emit_footer(out)?;
@@ -200,10 +200,10 @@ where
     // source map instead of hitting the file system. This also supports getting
     // original text for `FileName::Stdin`.
     let original_text =
-        if formatted_result.newline_style != NewlineStyle::Auto && *filename != FileName::Stdin {
+        if formatted_result.newline_style() != NewlineStyle::Auto && *filename != FileName::Stdin {
             Rc::new(fs::read_to_string(ensure_real_path(filename))?)
         } else {
-            match &formatted_result.original_snippet {
+            match formatted_result.original_text() {
                 Some(original_snippet) => Rc::new(original_snippet.to_owned()),
                 None => match parse_sess.and_then(|sess| sess.get_original_snippet(filename)) {
                     Some(ori) => ori,
@@ -215,7 +215,7 @@ where
     let formatted_file = FormattedFile {
         filename,
         original_text: original_text.as_str(),
-        formatted_text: &formatted_result.formatted_snippet.snippet,
+        formatted_text: formatted_result.formatted_text(),
     };
 
     emitter.emit_formatted_file(out, formatted_file)

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

@@ -49,8 +49,8 @@ impl<'a> Display for FormatReportFormatter<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let formatter = DisplayListFormatter::new(self.enable_colors, false);
 
-        for (file, errors) in self.report.format_result.borrow().iter() {
-            for error in errors.errors() {
+        for (file, errors) in self.report.format_result_as_rc().borrow().iter() {
+            for error in errors.errors_excluding_macro() {
                 let snippet = formatting_error_to_snippet(file, error);
                 writeln!(f, "{}\n", formatter.format(&DisplayList::from(snippet)))?;
             }
@@ -92,26 +92,26 @@ fn formatting_error_to_snippet(file: &FileName, error: &FormatError) -> Snippet
 }
 
 fn snippet_title(error: &FormatError) -> Annotation {
-    let annotation_type = error_kind_to_snippet_annotation_type(&error.kind);
+    let annotation_type = error_kind_to_snippet_annotation_type(&error.kind());
 
     Annotation {
         id: None,
-        label: Some(error.kind.to_string()),
+        label: Some(error.kind().to_string()),
         annotation_type,
     }
 }
 
 fn snippet_code_slice(file: &FileName, error: &FormatError) -> Slice {
     let annotations = slice_annotation(error).into_iter().collect();
     let origin = error
-        .line_num
+        .line_num()
         .as_ref()
         .map(|line_num| format!("{}:{}", file, line_num));
-    let source = error.line_str.clone().unwrap_or_else(|| String::new());
+    let source = error.line_str().unwrap_or("").to_owned();
 
     Slice {
         source,
-        line_start: error.line_num.unwrap_or(0),
+        line_start: error.line_num().unwrap_or(0),
         origin,
         fold: false,
         annotations,

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

@@ -5,19 +5,56 @@ use std::time::{Duration, Instant};
 
 use rustc_ast::ast;
 
+pub(crate) use syntux::session::ParseSess;
+
 use self::newline_style::apply_newline_style;
-use crate::comment::{CharClasses, FullCodeCharKind};
+use crate::formatting::{
+    comment::{CharClasses, FullCodeCharKind},
+    report::NonFormattedRange,
+    syntux::parser::{DirectoryOwnership, Parser, ParserError},
+    utils::count_newlines,
+    visitor::FmtVisitor,
+};
 use crate::config::{Config, FileName};
-use crate::syntux::parser::{DirectoryOwnership, Parser, ParserError};
-use crate::syntux::session::ParseSess;
-use crate::utils::count_newlines;
-use crate::visitor::FmtVisitor;
+use crate::result::OperationError;
 use crate::{
-    modules, ErrorKind, FormatError, FormatReport, FormatResult, Input, NonFormattedRange,
-    OperationError, OperationSetting, Verbosity,
+    ErrorKind, FormatError, FormatReport, FormatResult, Input, OperationSetting, Verbosity,
 };
 
+#[macro_use]
+mod utils;
+
+mod attr;
+mod chains;
+mod closures;
+mod comment;
+mod expr;
+mod imports;
+mod items;
+mod lists;
+mod macros;
+mod matches;
+mod missed_spans;
+pub(crate) mod modules;
 mod newline_style;
+mod overflow;
+mod pairs;
+mod patterns;
+mod reorder;
+mod rewrite;
+mod shape;
+mod skip;
+pub(crate) mod source_map;
+mod spanned;
+mod stmt;
+mod string;
+mod syntux;
+mod types;
+mod vertical;
+pub(crate) mod visitor;
+
+pub(crate) mod report;
+pub(crate) mod util;
 
 pub(crate) fn format_input_inner(
     input: Input,
@@ -32,6 +69,7 @@ pub(crate) fn format_input_inner(
         format_project(input, config, operation_setting)
     })
 }
+
 fn format_project(
     input: Input,
     config: &Config,
@@ -412,3 +450,61 @@ where
         f();
     }
 }
+
+/// Result of formatting a snippet of code along with ranges of lines that didn't get formatted,
+/// i.e., that got returned as they were originally.
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormattedSnippet {
+    snippet: String,
+    non_formatted_ranges: Vec<NonFormattedRange>,
+}
+
+impl FormattedSnippet {
+    /// In case the snippet needed to be wrapped in a function, this shifts down the ranges of
+    /// non-formatted code.
+    fn unwrap_code_block(&mut self) {
+        self.non_formatted_ranges.iter_mut().for_each(|range| {
+            *range = range.shift_up();
+        });
+    }
+
+    /// Returns `true` if the line n did not get formatted.
+    pub(crate) fn is_line_non_formatted(&self, n: usize) -> bool {
+        self.non_formatted_ranges
+            .iter()
+            .any(|range| range.contains(n))
+    }
+}
+
+impl AsRef<str> for FormattedSnippet {
+    fn as_ref(&self) -> &str {
+        self.snippet.as_str()
+    }
+}
+
+impl Input {
+    fn file_name(&self) -> FileName {
+        match *self {
+            Input::File(ref file) => FileName::Real(file.clone()),
+            Input::Text(..) => FileName::Stdin,
+        }
+    }
+
+    fn to_directory_ownership(&self) -> Option<DirectoryOwnership> {
+        match self {
+            Input::File(ref file) => {
+                // If there exists a directory with the same name as an input,
+                // then the input should be parsed as a sub module.
+                let file_stem = file.file_stem()?;
+                if file.parent()?.to_path_buf().join(file_stem).is_dir() {
+                    Some(DirectoryOwnership::Owned {
+                        relative: file_stem.to_str().map(ast::Ident::from_str),
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+}

rustfmt-core/rustfmt-lib/src/attr.rs renamed to rustfmt-core/rustfmt-lib/src/formatting/attr.rs

@@ -4,17 +4,22 @@ use rustc_ast::ast;
 use rustc_ast::attr::HasAttrs;
 use rustc_span::{symbol::sym, Span};
 
-use self::doc_comment::DocCommentFormatter;
-use crate::comment::{contains_comment, rewrite_doc_comment, CommentStyle};
-use crate::config::lists::*;
-use crate::config::IndentStyle;
-use crate::expr::rewrite_literal;
-use crate::lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
-use crate::overflow;
-use crate::rewrite::{Rewrite, RewriteContext};
-use crate::shape::Shape;
-use crate::types::{rewrite_path, PathContext};
-use crate::utils::{count_newlines, mk_sp};
+use doc_comment::DocCommentFormatter;
+use crate::config::{
+    lists::*,
+    IndentStyle,
+};
+
+use crate::formatting::{
+    comment::{contains_comment, rewrite_doc_comment, CommentStyle, recover_missing_comment_in_span},
+    expr::{rewrite_literal, span_ends_with_comma},
+    lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator},
+    overflow,
+    rewrite::{Rewrite, RewriteContext},
+    shape::Shape,
+    types::{rewrite_path, PathContext},
+    utils::{count_newlines, mk_sp},
+};
 
 mod doc_comment;
 
@@ -279,7 +284,7 @@ impl Rewrite for ast::MetaItem {
             }
             ast::MetaItemKind::List(ref list) => {
                 let path = rewrite_path(context, PathContext::Type, None, &self.path, shape)?;
-                let has_trailing_comma = crate::expr::span_ends_with_comma(context, self.span);
+                let has_trailing_comma = span_ends_with_comma(context, self.span);
                 overflow::rewrite_with_parens(
                     context,
                     &path,
@@ -398,7 +403,7 @@ impl<'a> Rewrite for [ast::Attribute] {
                 if let Some(missing_span) = missing_span {
                     let snippet = context.snippet(missing_span);
                     let (mla, mlb) = has_newlines_before_after_comment(snippet);
-                    let comment = crate::comment::recover_missing_comment_in_span(
+                    let comment = recover_missing_comment_in_span(
                         missing_span,
                         shape.with_max_width(context.config),
                         context,
@@ -428,7 +433,7 @@ impl<'a> Rewrite for [ast::Attribute] {
                     .get(derives.len())
                     .map(|next| mk_sp(attrs[derives.len() - 1].span.hi(), next.span.lo()));
                 if let Some(missing_span) = missing_span {
-                    let comment = crate::comment::recover_missing_comment_in_span(
+                    let comment = recover_missing_comment_in_span(
                         missing_span,
                         shape.with_max_width(context.config),
                         context,
@@ -461,7 +466,7 @@ impl<'a> Rewrite for [ast::Attribute] {
                 .get(1)
                 .map(|next| mk_sp(attrs[0].span.hi(), next.span.lo()));
             if let Some(missing_span) = missing_span {
-                let comment = crate::comment::recover_missing_comment_in_span(
+                let comment = recover_missing_comment_in_span(
                     missing_span,
                     shape.with_max_width(context.config),
                     context,

rustfmt-core/rustfmt-lib/src/attr/doc_comment.rs renamed to rustfmt-core/rustfmt-lib/src/formatting/attr/doc_comment.rs

@@ -1,6 +1,7 @@
-use crate::comment::CommentStyle;
 use std::fmt::{self, Display};
 
+use crate::formatting::comment::CommentStyle;
+
 /// Formats a string as a doc comment using the given [`CommentStyle`].
 pub(super) struct DocCommentFormatter<'a> {
     literal: &'a str,

rustfmt-core/rustfmt-lib/src/chains.rs renamed to rustfmt-core/rustfmt-lib/src/formatting/chains.rs

@@ -61,17 +61,19 @@ use std::cmp::min;
 use rustc_ast::{ast, ptr};
 use rustc_span::{symbol, BytePos, Span};
 
-use crate::comment::{rewrite_comment, CharClasses, FullCodeCharKind, RichChar};
 use crate::config::IndentStyle;
-use crate::expr::rewrite_call;
-use crate::lists::extract_pre_comment;
-use crate::macros::convert_try_mac;
-use crate::rewrite::{Rewrite, RewriteContext};
-use crate::shape::Shape;
-use crate::source_map::SpanUtils;
-use crate::utils::{
-    self, first_line_width, last_line_extendable, last_line_width, mk_sp, rewrite_ident,
-    trimmed_last_line_width, wrap_str,
+use crate::formatting::{
+    comment::{rewrite_comment, CharClasses, FullCodeCharKind, RichChar},
+    expr::rewrite_call,
+    lists::extract_pre_comment,
+    macros::convert_try_mac,
+    rewrite::{Rewrite, RewriteContext},
+    shape::Shape,
+    source_map::SpanUtils,
+    utils::{
+        self, first_line_width, last_line_extendable, last_line_width, mk_sp, rewrite_ident,
+        trimmed_last_line_width, wrap_str,
+    },
 };
 
 pub(crate) fn rewrite_chain(

rustfmt-core/rustfmt-lib/src/closures.rs renamed to rustfmt-core/rustfmt-lib/src/formatting/closures.rs

@@ -1,17 +1,23 @@
 use rustc_ast::{ast, ptr};
 use rustc_span::Span;
 
-use crate::attr::get_attrs_from_stmt;
-use crate::config::lists::*;
-use crate::config::{IndentStyle, SeparatorTactic};
-use crate::expr::{block_contains_comment, is_simple_block, is_unsafe_block, rewrite_cond};
-use crate::items::{span_hi_for_param, span_lo_for_param};
-use crate::lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
-use crate::overflow::OverflowableItem;
-use crate::rewrite::{Rewrite, RewriteContext};
-use crate::shape::Shape;
-use crate::source_map::SpanUtils;
-use crate::utils::{last_line_width, left_most_sub_expr, stmt_expr, NodeIdExt};
+use crate::config::{
+    lists::*,
+    IndentStyle,
+    SeparatorTactic,
+};
+use crate::formatting::{
+    attr::get_attrs_from_stmt,
+    expr::{block_contains_comment, is_simple_block, is_unsafe_block, rewrite_cond,
+           rewrite_block_with_visitor},
+    items::{span_hi_for_param, span_lo_for_param},
+    lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator},
+    overflow::OverflowableItem,
+    rewrite::{Rewrite, RewriteContext},
+    shape::Shape,
+    source_map::SpanUtils,
+    utils::{last_line_width, left_most_sub_expr, stmt_expr, NodeIdExt},
+};
 
 // This module is pretty messy because of the rules around closures and blocks:
 // FIXME - the below is probably no longer true in full.
@@ -156,7 +162,7 @@ fn rewrite_closure_with_block(
         rules: ast::BlockCheckMode::Default,
         span: body.span,
     };
-    let block = crate::expr::rewrite_block_with_visitor(
+    let block = rewrite_block_with_visitor(
         context,
         "",
         &block,