Add auto-fixable suggestion to remove unused imports

[killercup]

Warnings like the following should contain information in their diagnostics output that allows rustfix to remove the unused import.

warning: unused import: `std::io::prelude::*`
  --> src/tiso/tiso_msg.rs:10:5
   |
10 | use std::io::prelude::*;
   |     ^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::fmt`
  --> src/tiso/tiso_msg.rs:13:5
   |
13 | use std::fmt;
   |     ^^^^^^^^

The strategy is to suggest replacing the unused import with an empty string. There are two cases:

• Are all items in the use statement unused (e.g., std::fs in use std::fs; is unused)? Then remove the whole use statement.
• Are only some of the items imported by the use statement unused (e.g., File in use std::fs::{File, copy}; is unused)? Remove only these items but keep the use statement.

A quick search found this relevant file in typeck:

rust/src/librustc_typeck/check_unused.rs

Lines 27 to 46 in 7051754

	impl<'a, 'tcx> CheckVisitor<'a, 'tcx> {
	fn check_import(&self, id: ast::NodeId, span: Span) {
	let def_id = self.tcx.hir.local_def_id(id);
	if !self.tcx.maybe_unused_trait_import(def_id) {
	return;
	}
	let import_def_id = self.tcx.hir.local_def_id(id);
	if self.used_trait_imports.contains(&import_def_id) {
	return;
	}
	let msg = if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(span) {
	format!("unused import: `{}`", snippet)
	} else {
	"unused import".to_string()
	};
	self.tcx.lint_node(lint::builtin::UNUSED_IMPORTS, id, span, &msg);
	}
	}

Originally opened as https://github.com/killercup/rustfix/issues/56.

[JJJollyjim]

I'm taking a shot at writing this - it's my first attempt at touching rustc so there's a 50/50 chance that anything will come of it :)

[JJJollyjim]

My thinking on various edge cases:

When we encounter multiple unused items, like so:

warning: unused imports: `io`, `net`
 --> src/main.rs:1:22
  |
1 | use std::os::{unix::{io, net}, linux};
  |                      ^^  ^^^
  |
  = note: #[warn(unused_imports)] on by default

I'm assuming we want just a single suggestion with every unused item in this use tree removed.

In this case, should it be use std::os::{linux}; or use std::os::linux;?

How about if we would end up with unix::{self}/unix::self?

warning: unused imports: `io`, `net`
 --> src/main.rs:1:22
  |
1 | use std::os::unix::{io, self};
  |                     ^^  

Should the self component be removed from the path?

(In both cases I would lean towards applying these simplifications).

If we are making these simplifications, presumably it would be desirable to avoid touching parts of the tree that didn't have unused imports:

warning: unused imports: `io`, `net`
 --> src/main.rs:1:22
  |
1 | use std::os::{unix::{io, self}, linux::{self}};
  |                      ^^  

Would become use std::os::{unix, linux::{self}}; rather than use std::os::{unix, linux};

[JJJollyjim]

One roadblock encountered, for these squiggly bracket situations:

[skippable backgound] There are two stages of unused import checking (documented here). The first and main stage (in resolve) doesn't always have the knowledge to determine conclusively that an imported trait is actually unused. These candidates are saved for the later stage in typeck (the one killercup linked above).

---

A problem arises when an uncertain Trait import is alongside a concrete import in a single use:

https://play.rust-lang.org/?gist=a08ec0cd799f258f2a1c371cc3ca2f4c&version=nightly

warning: unused imports: `Bar`, `Foo`
 --> src/main.rs:3:12
  |
3 | use test::{Bar, Foo, Trait1, Trait2, C};
  |            ^^^  ^^^
  |
  = note: #[warn(unused_imports)] on by default

warning: unused import: `Trait2`
 --> src/main.rs:3:30
  |
3 | use test::{Bar, Foo, Trait1, Trait2, C};
  |                              ^^^^^^

These problems are found at different times, thus they produce two different diagnostics. This means that we can't emit a single suggestion to resolve all these issues (unless we instead buffer all the early warnings until the second stage of checking and report the issues together).

---

(The reason I am proposing emitting a single suggestion, aside from user-convenience, is so that we don't get conflicts applying two suggestions which both, say, remove a comma).

---

For now I will attempt to write a version which does not touch the uncertain traits, leaving them as is in the use.

[JJJollyjim]

Okay, I have a tested implementation here, which does not touch late-decided trait imports. I will have a look tomorrow at would will be necessary to cover those cases as well.

[euclio]

@JJJollyjim Any interest in reviving this?

[vors]

Oh please revive it, unused imports are killing me

[JJJollyjim]

@vors apparently someone else finished it

[JJJollyjim]

I had been working on it still, I will have a look at @pietroalbini's code later to see if there's anything I can contribute from my versison