Add broken_clippy_fixes_backed_out

Signed-off-by: hi-rustin <rustin.liu@gmail.com>

Author: Rustin170506

tests/testsuite/fix.rs

@@ -109,7 +109,6 @@ fn broken_fixes_backed_out() {
                             fs::File::create(&first).unwrap();
                         }
                     }
-
                     let status = Command::new("rustc")
                         .args(env::args().skip(1))
                         .status()
@@ -160,7 +159,157 @@ fn broken_fixes_backed_out() {
              and we would appreciate a bug report! You're likely to see \n\
              a number of compiler warnings after this message which cargo\n\
              attempted to fix but failed. If you could open an issue at\n\
-             [..]\n\
+             https://github.com/rust-lang/rust/issues\n\
+             quoting the full output of this command we'd be very appreciative!\n\
+             Note that you may be able to make some more progress in the near-term\n\
+             fixing code with the `--broken-code` flag\n\
+             \n\
+             The following errors were reported:\n\
+             error: expected one of `!` or `::`, found `rust`\n\
+             ",
+        )
+        .with_stderr_contains("Original diagnostics will follow.")
+        .with_stderr_contains("[WARNING] variable does not need to be mutable")
+        .with_stderr_does_not_contain("[..][FIXED][..]")
+        .run();
+
+    // Make sure the fix which should have been applied was backed out
+    assert!(p.read_file("bar/src/lib.rs").contains("let mut x = 3;"));
+}
+
+#[cargo_test]
+fn broken_clippy_fixes_backed_out() {
+    // A wrapper around `rustc` instead of calling `clippy`
+    let clippy_driver = project()
+        .at(cargo_test_support::paths::global_root().join("clippy-driver"))
+        .file("Cargo.toml", &basic_manifest("clippy-driver", "0.0.1"))
+        .file(
+            "src/main.rs",
+            r#"
+            fn main() {
+                let mut args = std::env::args_os();
+                let _me = args.next().unwrap();
+                let rustc = args.next().unwrap();
+                let status = std::process::Command::new(rustc).args(args).status().unwrap();
+                std::process::exit(status.code().unwrap_or(1));
+            }
+            "#,
+        )
+        .build();
+    clippy_driver.cargo("build").run();
+
+    // This works as follows:
+    // - Create a `rustc` shim (the "foo" project) which will pretend that the
+    //   verification step fails.
+    // - There is an empty build script so `foo` has `OUT_DIR` to track the steps.
+    // - The first "check", `foo` creates a file in OUT_DIR, and it completes
+    //   successfully with a warning diagnostic to remove unused `mut`.
+    // - rustfix removes the `mut`.
+    // - The second "check" to verify the changes, `foo` swaps out the content
+    //   with something that fails to compile. It creates a second file so it
+    //   won't do anything in the third check.
+    // - cargo fix discovers that the fix failed, and it backs out the changes.
+    // - The third "check" is done to display the original diagnostics of the
+    //   original code.
+    let p = project()
+        .file(
+            "foo/Cargo.toml",
+            r#"
+                [package]
+                name = 'foo'
+                version = '0.1.0'
+                [workspace]
+            "#,
+        )
+        .file(
+            "foo/src/main.rs",
+            r#"
+                use std::env;
+                use std::fs;
+                use std::io::Write;
+                use std::path::{Path, PathBuf};
+                use std::process::{self, Command};
+
+                fn main() {
+                    // Ignore calls to things like --print=file-names and compiling build.rs.
+                    // Also compatible for rustc invocations with `@path` argfile.
+                    let is_lib_rs = env::args_os()
+                        .map(PathBuf::from)
+                        .flat_map(|p| if let Some(p) = p.to_str().unwrap_or_default().strip_prefix("@") {
+                            fs::read_to_string(p).unwrap().lines().map(PathBuf::from).collect()
+                        } else {
+                            vec![p]
+                        })
+                        .any(|l| l == Path::new("src/lib.rs"));
+                    if is_lib_rs {
+                        let path = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+                        let first = path.join("first");
+                        let second = path.join("second");
+                        if first.exists() && !second.exists() {
+                            fs::write("src/lib.rs", b"not rust code").unwrap();
+                            fs::File::create(&second).unwrap();
+                        } else {
+                            fs::File::create(&first).unwrap();
+                        }
+                    }
+                    let status = Command::new("rustc")
+                        .args(env::args().skip(1))
+                        .status()
+                        .expect("failed to run rustc");
+                    process::exit(status.code().unwrap_or(2));
+                }
+            "#,
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+                [package]
+                name = 'bar'
+                version = '0.1.0'
+                [workspace]
+            "#,
+        )
+        .file("bar/build.rs", "fn main() {}")
+        .file(
+            "bar/src/lib.rs",
+            r#"
+                pub fn foo() {
+                    let mut x = 3;
+                    drop(x);
+                }
+            "#,
+        )
+        .build();
+
+    // Build our rustc shim
+    p.cargo("build").cwd("foo").run();
+
+    // Attempt to fix code, but our shim will always fail the second compile.
+    // Also, we use `clippy` as a workspace wrapper to make sure that we properly
+    // generate the report bug text.
+    p.cargo("fix --allow-no-vcs --lib")
+        .cwd("bar")
+        .env("__CARGO_FIX_YOLO", "1")
+        .env("RUSTC", p.root().join("foo/target/debug/foo"))
+        //  We can't use `clippy` so we use a `rustc` workspace wrapper instead
+        .env(
+            "RUSTC_WORKSPACE_WRAPPER",
+            clippy_driver.bin("clippy-driver"),
+        )
+        .with_stderr_contains(
+            "warning: failed to automatically apply fixes suggested by rustc \
+             to crate `bar`\n\
+             \n\
+             after fixes were automatically applied the compiler reported \
+             errors within these files:\n\
+             \n  \
+             * src/lib.rs\n\
+             \n\
+             This likely indicates a bug in either rustc or cargo itself,\n\
+             and we would appreciate a bug report! You're likely to see \n\
+             a number of compiler warnings after this message which cargo\n\
+             attempted to fix but failed. If you could open an issue at\n\
+             https://github.com/rust-lang/rust-clippy/issues\n\
              quoting the full output of this command we'd be very appreciative!\n\
              Note that you may be able to make some more progress in the near-term\n\
              fixing code with the `--broken-code` flag\n\