Merge branch 'master' into stdin_emit

Author: jugglerchris

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 
 name = "rustfmt-nightly"
-version = "1.4.9"
+version = "1.4.10"
 authors = ["Nicholas Cameron <[email protected]>", "The Rustfmt developers"]
 description = "Tool to find and fix Rust formatting issues"
 repository = "https://github.com/rust-lang/rustfmt"
@@ -56,6 +56,7 @@ ignore = "0.4.6"
 annotate-snippets = { version = "0.6", features = ["ansi_term"] }
 structopt = "0.3"
 rustfmt-config_proc_macro = { version = "0.2", path = "config_proc_macro" }
+lazy_static = "1.0.0"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.
 # See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`
@@ -74,5 +75,3 @@ version = "610.0.0"
 package = "rustc-ap-syntax_pos"
 version = "610.0.0"
 
-[dev-dependencies]
-lazy_static = "1.0.0"

Cargo.toml

@@ -15,7 +15,7 @@ set -ex
 # it again.
 #
 #which cargo-fmt || cargo install --force
-cargo install --path . --force 
+cargo install --path . --force --locked
 
 echo "Integration tests for: ${INTEGRATION}"
 cargo fmt -- --version

ci/integration.sh

@@ -56,6 +56,10 @@ pub struct Opts {
     /// Format all packages (only usable in workspaces)
     #[structopt(long = "all")]
     format_all: bool,
+
+    /// Run rustfmt in check mode
+    #[structopt(long = "check")]
+    check: bool,
 }
 
 fn main() {
@@ -104,6 +108,12 @@ fn execute() -> i32 {
 
     let strategy = CargoFmtStrategy::from_opts(&opts);
     let mut rustfmt_args = opts.rustfmt_options;
+    if opts.check {
+        let check_flag = String::from("--check");
+        if !rustfmt_args.contains(&check_flag) {
+            rustfmt_args.push(check_flag);
+        }
+    }
     if let Some(message_format) = opts.message_format {
         if let Err(msg) = convert_message_format_to_rustfmt_args(&message_format, &mut rustfmt_args)
         {
@@ -544,6 +554,7 @@ mod cargo_fmt_tests {
         assert_eq!(false, o.quiet);
         assert_eq!(false, o.verbose);
         assert_eq!(false, o.version);
+        assert_eq!(false, o.check);
         assert_eq!(empty, o.packages);
         assert_eq!(empty, o.rustfmt_options);
         assert_eq!(false, o.format_all);
@@ -562,13 +573,15 @@ mod cargo_fmt_tests {
             "p2",
             "--message-format",
             "short",
+            "--check",
             "--",
             "--edition",
             "2018",
         ]);
         assert_eq!(true, o.quiet);
         assert_eq!(false, o.verbose);
         assert_eq!(false, o.version);
+        assert_eq!(true, o.check);
         assert_eq!(vec!["p1", "p2"], o.packages);
         assert_eq!(vec!["--edition", "2018"], o.rustfmt_options);
         assert_eq!(false, o.format_all);
@@ -597,12 +610,12 @@ mod cargo_fmt_tests {
     fn mandatory_separator() {
         assert!(
             Opts::clap()
-                .get_matches_from_safe(&["test", "--check"])
+                .get_matches_from_safe(&["test", "--emit"])
                 .is_err()
         );
         assert!(
             !Opts::clap()
-                .get_matches_from_safe(&["test", "--", "--check"])
+                .get_matches_from_safe(&["test", "--", "--emit"])
                 .is_err()
         );
     }

src/cargo-fmt/main.rs

@@ -3,7 +3,7 @@ use syntax::{ast, ptr};
 
 use crate::attr::get_attrs_from_stmt;
 use crate::config::lists::*;
-use crate::config::Version;
+use crate::config::{IndentStyle, SeparatorTactic, Version};
 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};
@@ -43,7 +43,7 @@ pub(crate) fn rewrite_closure(
 
     if let ast::ExprKind::Block(ref block, _) = body.kind {
         // The body of the closure is an empty block.
-        if block.stmts.is_empty() && !block_contains_comment(block, context.source_map) {
+        if block.stmts.is_empty() && !block_contains_comment(context, block) {
             return body
                 .rewrite(context, shape)
                 .map(|s| format!("{} {}", prefix, s));
@@ -112,7 +112,7 @@ fn needs_block(block: &ast::Block, prefix: &str, context: &RewriteContext<'_>) -
     is_unsafe_block(block)
         || block.stmts.len() > 1
         || has_attributes
-        || block_contains_comment(block, context.source_map)
+        || block_contains_comment(context, block)
         || prefix.contains('\n')
 }
 
@@ -238,9 +238,16 @@ fn rewrite_closure_fn_decl(
         .shrink_left(is_async.len() + mover.len() + immovable.len())?
         .sub_width(4)?;
 
+    let indent_style = context.config.indent_style();
+
     // 1 = |
     let param_offset = nested_shape.indent + 1;
-    let param_shape = nested_shape.offset_left(1)?.visual_indent(0);
+    let param_shape = match indent_style {
+        IndentStyle::Block => {
+            Shape::indented(shape.indent.block_indent(context.config), context.config)
+        }
+        IndentStyle::Visual => nested_shape.offset_left(1)?.visual_indent(0),
+    };
     let ret_str = fn_decl.output.rewrite(context, param_shape)?;
 
     let param_items = itemize_list(
@@ -273,10 +280,31 @@ fn rewrite_closure_fn_decl(
         .tactic(tactic)
         .preserve_newline(true);
     let list_str = write_list(&item_vec, &fmt)?;
-    let mut prefix = format!("{}{}{}|{}|", is_async, immovable, mover, list_str);
+    let one_line_budget = context.budget(param_shape.indent.width());
+    let multi_line_params = match indent_style {
+        IndentStyle::Block => list_str.contains('\n') || list_str.len() > one_line_budget,
+        _ => false,
+    };
+    let put_params_in_block = multi_line_params && !item_vec.is_empty();
+    let param_str = if put_params_in_block {
+        let trailing_comma = match context.config.trailing_comma() {
+            SeparatorTactic::Never => "",
+            _ => ",",
+        };
+        format!(
+            "{}{}{}{}",
+            param_shape.indent.to_string_with_newline(context.config),
+            &list_str,
+            trailing_comma,
+            shape.indent.to_string_with_newline(context.config)
+        )
+    } else {
+        list_str
+    };
+    let mut prefix = format!("{}{}{}|{}|", is_async, immovable, mover, param_str);
 
     if !ret_str.is_empty() {
-        if prefix.contains('\n') {
+        if prefix.contains('\n') && !put_params_in_block {
             prefix.push('\n');
             prefix.push_str(&param_offset.to_string(context.config));
         } else {
@@ -304,7 +332,7 @@ pub(crate) fn rewrite_last_closure(
             ast::ExprKind::Block(ref block, _)
                 if !is_unsafe_block(block)
                     && !context.inside_macro()
-                    && is_simple_block(block, Some(&body.attrs), context.source_map) =>
+                    && is_simple_block(context, block, Some(&body.attrs)) =>
             {
                 stmt_expr(&block.stmts[0]).unwrap_or(body)
             }

src/closures.rs

@@ -112,7 +112,7 @@ impl<'a> CommentStyle<'a> {
     }
 }
 
-fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle<'_> {
+pub(crate) fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle<'_> {
     if !normalize_comments {
         if orig.starts_with("/**") && !orig.starts_with("/**/") {
             CommentStyle::DoubleBullet
@@ -976,6 +976,7 @@ fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle<'_>) -> (&'a s
 
 pub(crate) trait FindUncommented {
     fn find_uncommented(&self, pat: &str) -> Option<usize>;
+    fn find_last_uncommented(&self, pat: &str) -> Option<usize>;
 }
 
 impl FindUncommented for str {
@@ -1001,6 +1002,19 @@ impl FindUncommented for str {
             None => Some(self.len() - pat.len()),
         }
     }
+
+    fn find_last_uncommented(&self, pat: &str) -> Option<usize> {
+        if let Some(left) = self.find_uncommented(pat) {
+            let mut result = left;
+            // add 1 to use find_last_uncommented for &str after pat
+            while let Some(next) = self[(result + 1)..].find_last_uncommented(pat) {
+                result += next + 1;
+            }
+            Some(result)
+        } else {
+            None
+        }
+    }
 }
 
 // Returns the first byte position after the first comment. The given string
@@ -1556,10 +1570,10 @@ pub(crate) fn recover_comment_removed(
         // We missed some comments. Warn and keep the original text.
         if context.config.error_on_unformatted() {
             context.report.append(
-                context.source_map.span_to_filename(span).into(),
+                context.parse_sess.span_to_filename(span),
                 vec![FormattingError::from_span(
                     span,
-                    &context.source_map,
+                    &context.parse_sess,
                     ErrorKind::LostComment,
                 )],
             );
@@ -1882,6 +1896,16 @@ mod test {
         check("\"/* abc", "abc", Some(4));
     }
 
+    #[test]
+    fn test_find_last_uncommented() {
+        fn check(haystack: &str, needle: &str, expected: Option<usize>) {
+            assert_eq!(expected, haystack.find_last_uncommented(needle));
+        }
+        check("foo test bar test", "test", Some(13));
+        check("test,", "test", Some(0));
+        check("nothing", "test", None);
+    }
+
     #[test]
     fn test_filter_normal_code() {
         let s = r#"