auto merge of #4803 : alexcrichton/rust/fix-unused-imports, r=graydon

The first commit message has most of the comments, but this pull request basically fixes a lot of issues surrounding the `unused_imports` warning/deny attribute.

Before this patch there were these problems:

1. Unused imports from `prelude.rs` were warned about with dummy spans, leading to a large number of confusing warnings.
2. Unused imports from `intrinsic.rs` were warned about with the file `<intrinsic>` which couldn't be forced to go away
3. Methods used from imported traites (like `io::WriterUtil`) resulted in an unused warning of the import even though it was used.
4. If one `use` statement imported N modules, M of which weren't used, M warning statements were issued.
5. If a glob import statement was used, each public export of the target module which wasn't used had a warning issued.

This patch deals with all these cases by doing:

1. Ignore unused imports from `prelude.rs` (indicated by a dummy span of 0)
2. Ignore unused imports from `intrinsic.rs` (test on the imported module name, is there a better way?)
3. Track when imported modules are used as candidates for methods, and just assume they're used. This may not end up being the actual case, but in theory not warning about an unused thing is worse than warning about a used thing.
4. Only issue one warning statement
5. Only issue one warning statement.

This is the first time I've edited the compiler itself, and I tried to keep up with the style around, but I may have missed something here or there...

src/test/compile-fail/unused-imports-warn.rs

@@ -8,23 +8,39 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:unused import
-// compile-flags:-W unused-imports
+// compile-flags: -D unused-imports
+
 use cal = bar::c::cc;
 
+use core::either::Right;        //~ ERROR unused import
+
+use core::util::*;              // shouldn't get errors for not using
+                                // everything imported
+
+// Should only get one error instead of two errors here
+use core::option::{Some, None}; //~ ERROR unused import
+
+use core::io::ReaderUtil;       //~ ERROR unused import
+// Be sure that if we just bring some methods into scope that they're also
+// counted as being used.
+use core::io::WriterUtil;
+
 mod foo {
-    pub type point = {x: int, y: int};
-    pub type square = {p: point, h: uint, w: uint};
+    pub struct Point{x: int, y: int}
+    pub struct Square{p: Point, h: uint, w: uint}
 }
 
 mod bar {
     pub mod c {
-        use foo::point;
-        use foo::square;
-        pub fn cc(p: point) -> str { return 2 * (p.x + p.y); }
+        use foo::Point;
+        use foo::Square; //~ ERROR unused import
+        pub fn cc(p: Point) -> int { return 2 * (p.x + p.y); }
     }
 }
 
 fn main() {
-    cal({x:3, y:9});
+    cal(foo::Point{x:3, y:9});
+    let a = 3;
+    ignore(a);
+    io::stdout().write_str(~"a");
 }